26 files changed, 1031 insertions, 1007 deletions

diff --git a/src/animation/AnimManager.cpp b/src/animation/AnimManager.cpp
index 557bd842..c66997ce 100644
--- a/src/animation/AnimManager.cpp
+++ b/src/animation/AnimManager.cpp
@@ -19,68 +19,68 @@ CAnimBlendAssocGroup *CAnimManager::ms_aAnimAssocGroups;
 CLinkList<CAnimBlendHierarchy*> CAnimManager::ms_animCache;
 
 AnimAssocDesc aStdAnimDescs[] = {
-	{ ANIM_WALK, ASSOC_REPEAT | ASSOC_MOVEMENT | ASSOC_HAS_TRANSLATION | ASSOC_WALK },
-	{ ANIM_RUN, ASSOC_REPEAT | ASSOC_MOVEMENT | ASSOC_HAS_TRANSLATION | ASSOC_WALK },
-	{ ANIM_SPRINT, ASSOC_REPEAT | ASSOC_MOVEMENT | ASSOC_HAS_TRANSLATION | ASSOC_WALK },
-	{ ANIM_IDLE_STANCE, ASSOC_REPEAT },
-	{ ANIM_WALK_START, ASSOC_HAS_TRANSLATION },
-	{ ANIM_RUN_STOP, ASSOC_DELETEFADEDOUT | ASSOC_HAS_TRANSLATION },
-	{ ANIM_RUN_STOP_R, ASSOC_DELETEFADEDOUT | ASSOC_HAS_TRANSLATION },
-	{ ANIM_IDLE_CAM, ASSOC_REPEAT | ASSOC_PARTIAL },
-	{ ANIM_IDLE_HBHB, ASSOC_REPEAT | ASSOC_PARTIAL },
-	{ ANIM_IDLE_TIRED, ASSOC_REPEAT },
-	{ ANIM_IDLE_ARMED, ASSOC_REPEAT | ASSOC_PARTIAL },
-	{ ANIM_IDLE_CHAT, ASSOC_REPEAT | ASSOC_PARTIAL },
-	{ ANIM_IDLE_TAXI, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_KO_SHOT_FRONT1, ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION | ASSOC_FRONTAL  },
-	{ ANIM_KO_SHOT_FRONT2, ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION | ASSOC_FRONTAL  },
-	{ ANIM_KO_SHOT_FRONT3, ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION | ASSOC_FRONTAL  },
-	{ ANIM_KO_SHOT_FRONT4, ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION | ASSOC_FRONTAL  },
-	{ ANIM_KO_SHOT_FACE, ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION | ASSOC_FRONTAL  },
-	{ ANIM_KO_SHOT_STOM, ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
-	{ ANIM_KO_SHOT_ARML, ASSOC_PARTIAL | ASSOC_FRONTAL  },
-	{ ANIM_KO_SHOT_ARMR, ASSOC_PARTIAL | ASSOC_FRONTAL  },
-	{ ANIM_KO_SHOT_LEGL, ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
-	{ ANIM_KO_SHOT_LEGR, ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
-	{ ANIM_KD_LEFT, ASSOC_PARTIAL | ASSOC_FRONTAL  },
-	{ ANIM_KD_RIGHT, ASSOC_PARTIAL | ASSOC_FRONTAL  },
-	{ ANIM_KO_SKID_FRONT, ASSOC_PARTIAL },
-	{ ANIM_KO_SPIN_R, ASSOC_PARTIAL },
-	{ ANIM_KO_SKID_BACK, ASSOC_PARTIAL | ASSOC_FRONTAL  },
-	{ ANIM_KO_SPIN_L, ASSOC_PARTIAL },
-	{ ANIM_SHOT_FRONT_PARTIAL, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_NOWALK  },
-	{ ANIM_SHOT_LEFT_PARTIAL, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_NOWALK  },
-	{ ANIM_SHOT_BACK_PARTIAL, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_NOWALK  },
-	{ ANIM_SHOT_RIGHT_PARTIAL, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_NOWALK  },
-	{ ANIM_HIT_FRONT, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
-	{ ANIM_HIT_LEFT, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_HIT_BACK, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
-	{ ANIM_HIT_RIGHT, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_FLOOR_HIT, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
+	{ ANIM_STD_WALK, ASSOC_REPEAT | ASSOC_MOVEMENT | ASSOC_HAS_TRANSLATION | ASSOC_WALK },
+	{ ANIM_STD_RUN, ASSOC_REPEAT | ASSOC_MOVEMENT | ASSOC_HAS_TRANSLATION | ASSOC_WALK },
+	{ ANIM_STD_RUNFAST, ASSOC_REPEAT | ASSOC_MOVEMENT | ASSOC_HAS_TRANSLATION | ASSOC_WALK },
+	{ ANIM_STD_IDLE, ASSOC_REPEAT },
+	{ ANIM_STD_STARTWALK, ASSOC_HAS_TRANSLATION },
+	{ ANIM_STD_RUNSTOP1, ASSOC_DELETEFADEDOUT | ASSOC_HAS_TRANSLATION },
+	{ ANIM_STD_RUNSTOP2, ASSOC_DELETEFADEDOUT | ASSOC_HAS_TRANSLATION },
+	{ ANIM_STD_IDLE_CAM, ASSOC_REPEAT | ASSOC_PARTIAL },
+	{ ANIM_STD_IDLE_HBHB, ASSOC_REPEAT | ASSOC_PARTIAL },
+	{ ANIM_STD_IDLE_TIRED, ASSOC_REPEAT },
+	{ ANIM_STD_IDLE_BIGGUN, ASSOC_REPEAT | ASSOC_PARTIAL },
+	{ ANIM_STD_CHAT, ASSOC_REPEAT | ASSOC_PARTIAL },
+	{ ANIM_STD_HAILTAXI, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_KO_FRONT, ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION | ASSOC_FRONTAL  },
+	{ ANIM_STD_KO_LEFT, ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION | ASSOC_FRONTAL  },
+	{ ANIM_STD_KO_BACK, ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION | ASSOC_FRONTAL  },
+	{ ANIM_STD_KO_RIGHT, ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION | ASSOC_FRONTAL  },
+	{ ANIM_STD_KO_SHOT_FACE, ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION | ASSOC_FRONTAL  },
+	{ ANIM_STD_KO_SHOT_STOMACH, ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
+	{ ANIM_STD_KO_SHOT_ARM_L, ASSOC_PARTIAL | ASSOC_FRONTAL  },
+	{ ANIM_STD_KO_SHOT_ARM_R, ASSOC_PARTIAL | ASSOC_FRONTAL  },
+	{ ANIM_STD_KO_SHOT_LEG_L, ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
+	{ ANIM_STD_KO_SHOT_LEG_R, ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
+	{ ANIM_STD_SPINFORWARD_LEFT, ASSOC_PARTIAL | ASSOC_FRONTAL  },
+	{ ANIM_STD_SPINFORWARD_RIGHT, ASSOC_PARTIAL | ASSOC_FRONTAL  },
+	{ ANIM_STD_HIGHIMPACT_FRONT, ASSOC_PARTIAL },
+	{ ANIM_STD_HIGHIMPACT_LEFT, ASSOC_PARTIAL },
+	{ ANIM_STD_HIGHIMPACT_BACK, ASSOC_PARTIAL | ASSOC_FRONTAL  },
+	{ ANIM_STD_HIGHIMPACT_RIGHT, ASSOC_PARTIAL },
+	{ ANIM_STD_HITBYGUN_FRONT, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_NOWALK  },
+	{ ANIM_STD_HITBYGUN_LEFT, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_NOWALK  },
+	{ ANIM_STD_HITBYGUN_BACK, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_NOWALK  },
+	{ ANIM_STD_HITBYGUN_RIGHT, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_NOWALK  },
+	{ ANIM_STD_HIT_FRONT, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
+	{ ANIM_STD_HIT_LEFT, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_HIT_BACK, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
+	{ ANIM_STD_HIT_RIGHT, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_HIT_FLOOR, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
 #if GTA_VERSION <= GTA3_PS2_160
-	{ ANIM_HIT_BODY, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_HIT_BODY, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
 #endif
-	{ ANIM_HIT_BODYBLOW, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
-	{ ANIM_HIT_CHEST, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
-	{ ANIM_HIT_HEAD, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
-	{ ANIM_HIT_WALK, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
-	{ ANIM_HIT_WALL, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
-	{ ANIM_FLOOR_HIT_F, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL | ASSOC_FRONTAL  },
-	{ ANIM_HIT_BEHIND, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_PUNCH_R, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_KICK_FLOOR, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_WEAPON_BAT_H, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_WEAPON_BAT_V, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_WEAPON_HGUN_BODY, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_NOWALK  },
-	{ ANIM_WEAPON_AK_BODY, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_WEAPON_PUMP, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_WEAPON_SNIPER, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_WEAPON_THROW, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_WEAPON_THROWU, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_WEAPON_START_THROW, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_BOMBER, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_NOWALK  },
-	{ ANIM_HGUN_RELOAD, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_NOWALK  },
-	{ ANIM_AK_RELOAD, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_NOWALK  },
+	{ ANIM_STD_HIT_BODYBLOW, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
+	{ ANIM_STD_HIT_CHEST, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
+	{ ANIM_STD_HIT_HEAD, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
+	{ ANIM_STD_HIT_WALK, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
+	{ ANIM_STD_HIT_WALL, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
+	{ ANIM_STD_HIT_FLOOR_FRONT, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL | ASSOC_FRONTAL  },
+	{ ANIM_STD_HIT_BEHIND, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_PUNCH, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_KICKGROUND, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_WEAPON_BAT_H, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_WEAPON_BAT_V, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_WEAPON_HGUN_BODY, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_NOWALK  },
+	{ ANIM_STD_WEAPON_AK_BODY, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_WEAPON_PUMP, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_WEAPON_SNIPER, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_WEAPON_THROW, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_THROW_UNDER, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_START_THROW, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_DETONATE, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_NOWALK  },
+	{ ANIM_STD_HGUN_RELOAD, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_NOWALK  },
+	{ ANIM_STD_AK_RELOAD, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_NOWALK  },
 #ifdef PC_PLAYER_CONTROLS
 	// maybe wrong define, but unused anyway
 	{ ANIM_FPS_PUNCH, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
@@ -91,121 +91,121 @@ AnimAssocDesc aStdAnimDescs[] = {
 	{ ANIM_FPS_M16, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
 	{ ANIM_FPS_ROCKET, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
 #endif
-	{ ANIM_FIGHT_IDLE, ASSOC_REPEAT },
-	{ ANIM_FIGHT2_IDLE, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_FIGHT_SH_F, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
-	{ ANIM_FIGHT_BODYBLOW, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_FIGHT_HEAD, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_FIGHT_KICK, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_FIGHT_KNEE, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_FIGHT_LHOOK, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_FIGHT_PUNCH, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_FIGHT_ROUNDHOUSE, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
-	{ ANIM_FIGHT_LONGKICK, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
-	{ ANIM_FIGHT_PPUNCH, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL | ASSOC_NOWALK  },
-	{ ANIM_CAR_JACKED_RHS, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
-	{ ANIM_CAR_LJACKED_RHS, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
-	{ ANIM_CAR_JACKED_LHS, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
-	{ ANIM_CAR_LJACKED_LHS, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
-	{ ANIM_CAR_QJACK, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_CAR_QJACKED, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
-	{ ANIM_CAR_ALIGN_LHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_CAR_ALIGNHI_LHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_CAR_OPEN_LHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_CAR_DOORLOCKED_LHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_CAR_PULLOUT_LHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_CAR_PULLOUT_LOW_LHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_CAR_GETIN_LHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_CAR_GETIN_LOW_LHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_CAR_CLOSEDOOR_LHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_CAR_CLOSEDOOR_LOW_LHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_CAR_ROLLDOOR, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_CAR_ROLLDOOR_LOW, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_CAR_GETOUT_LHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_CAR_GETOUT_LOW_LHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_CAR_CLOSE_LHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_CAR_ALIGN_RHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_CAR_ALIGNHI_RHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_CAR_OPEN_RHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_CAR_DOORLOCKED_RHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_CAR_PULLOUT_RHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_CAR_PULLOUT_LOW_RHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_CAR_GETIN_RHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_CAR_GETIN_LOW_RHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_CAR_CLOSEDOOR_RHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_CAR_CLOSEDOOR_LOW_RHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_CAR_SHUFFLE_RHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_CAR_LSHUFFLE_RHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_CAR_SIT, ASSOC_DELETEFADEDOUT },
-	{ ANIM_CAR_LSIT, ASSOC_DELETEFADEDOUT },
-	{ ANIM_CAR_SITP, ASSOC_DELETEFADEDOUT },
-	{ ANIM_CAR_SITPLO, ASSOC_DELETEFADEDOUT },
-	{ ANIM_DRIVE_L, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
-	{ ANIM_DRIVE_R, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
-	{ ANIM_DRIVE_LOW_L, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
-	{ ANIM_DRIVE_LOW_R, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
-	{ ANIM_DRIVEBY_L, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
-	{ ANIM_DRIVEBY_R, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
-	{ ANIM_CAR_LB, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
-	{ ANIM_DRIVE_BOAT, ASSOC_DELETEFADEDOUT },
-	{ ANIM_CAR_GETOUT_RHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_CAR_GETOUT_LOW_RHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_CAR_CLOSE_RHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_CAR_HOOKERTALK, ASSOC_REPEAT | ASSOC_PARTIAL },
-	{ ANIM_COACH_OPEN_L, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_COACH_OPEN_R, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_COACH_IN_L, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_COACH_IN_R, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_COACH_OUT_L, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_TRAIN_GETIN, ASSOC_PARTIAL },
-	{ ANIM_TRAIN_GETOUT, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_CAR_CRAWLOUT_RHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_CAR_CRAWLOUT_RHS2, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_VAN_OPEN_L, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_VAN_GETIN_L, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_VAN_CLOSE_L, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_VAN_GETOUT_L, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_VAN_OPEN, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_VAN_GETIN, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_VAN_CLOSE, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_VAN_GETOUT, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_GETUP1, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
-	{ ANIM_GETUP2, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
-	{ ANIM_GETUP3, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
-	{ ANIM_GETUP_FRONT, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
-	{ ANIM_JUMP_LAUNCH, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_JUMP_GLIDE, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
-	{ ANIM_JUMP_LAND, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
-	{ ANIM_FALL_FALL, ASSOC_REPEAT | ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
-	{ ANIM_FALL_GLIDE, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
-	{ ANIM_FALL_LAND, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
-	{ ANIM_FALL_COLLAPSE, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
-	{ ANIM_EV_STEP, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
-	{ ANIM_EV_DIVE, ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION | ASSOC_FRONTAL  },
-	{ ANIM_XPRESS_SCRATCH, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_IDLE  },
-	{ ANIM_ROAD_CROSS, ASSOC_REPEAT | ASSOC_PARTIAL },
-	{ ANIM_TURN_180, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_ARREST_GUN, ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
-	{ ANIM_DROWN, ASSOC_PARTIAL },
-	{ ANIM_CPR, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_DUCK_DOWN, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
-	{ ANIM_DUCK_LOW, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
-	{ ANIM_RBLOCK_CSHOOT, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
-	{ ANIM_WEAPON_THROWU2, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_HANDSUP, ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
-	{ ANIM_HANDSCOWER, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
-	{ ANIM_FUCKU, ASSOC_DELETEFADEDOUT | ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_NOWALK  },
-	{ ANIM_PHONE_IN, ASSOC_PARTIAL },
-	{ ANIM_PHONE_OUT, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
-	{ ANIM_PHONE_TALK, ASSOC_REPEAT | ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
+	{ ANIM_STD_FIGHT_IDLE, ASSOC_REPEAT },
+	{ ANIM_STD_FIGHT_2IDLE, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_FIGHT_SHUFFLE_F, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
+	{ ANIM_STD_FIGHT_BODYBLOW, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_FIGHT_HEAD, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_FIGHT_KICK, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_FIGHT_KNEE, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_FIGHT_LHOOK, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_FIGHT_PUNCH, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_FIGHT_ROUNDHOUSE, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
+	{ ANIM_STD_FIGHT_LONGKICK, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
+	{ ANIM_STD_PARTIAL_PUNCH, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL | ASSOC_NOWALK  },
+	{ ANIM_STD_JACKEDCAR_RHS, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
+	{ ANIM_STD_JACKEDCAR_LO_RHS, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
+	{ ANIM_STD_JACKEDCAR_LHS, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
+	{ ANIM_STD_JACKEDCAR_LO_LHS, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
+	{ ANIM_STD_QUICKJACK, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_QUICKJACKED, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
+	{ ANIM_STD_CAR_ALIGN_DOOR_LHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_CAR_ALIGNHI_DOOR_LHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_CAR_OPEN_DOOR_LHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_CARDOOR_LOCKED_LHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_CAR_PULL_OUT_PED_LHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_CAR_PULL_OUT_PED_LO_LHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_CAR_GET_IN_LHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_CAR_GET_IN_LO_LHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_CAR_CLOSE_DOOR_LHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_CAR_CLOSE_DOOR_LO_LHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_CAR_CLOSE_DOOR_ROLLING_LHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_CAR_CLOSE_DOOR_ROLLING_LO_LHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_GETOUT_LHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_GETOUT_LO_LHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_CAR_CLOSE_LHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_CAR_ALIGN_DOOR_RHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_CAR_ALIGNHI_DOOR_RHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_CAR_OPEN_DOOR_RHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_CARDOOR_LOCKED_RHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_CAR_PULL_OUT_PED_RHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_CAR_PULL_OUT_PED_LO_RHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_CAR_GET_IN_RHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_CAR_GET_IN_LO_RHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_CAR_CLOSE_DOOR_RHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_CAR_CLOSE_DOOR_LO_RHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_CAR_SHUFFLE_RHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_CAR_SHUFFLE_LO_RHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_CAR_SIT, ASSOC_DELETEFADEDOUT },
+	{ ANIM_STD_CAR_SIT_LO, ASSOC_DELETEFADEDOUT },
+	{ ANIM_STD_CAR_SIT_P, ASSOC_DELETEFADEDOUT },
+	{ ANIM_STD_CAR_SIT_P_LO, ASSOC_DELETEFADEDOUT },
+	{ ANIM_STD_CAR_DRIVE_LEFT, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
+	{ ANIM_STD_CAR_DRIVE_RIGHT, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
+	{ ANIM_STD_CAR_DRIVE_LEFT_LO, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
+	{ ANIM_STD_CAR_DRIVE_RIGHT_LO, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
+	{ ANIM_STD_CAR_DRIVEBY_LEFT, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
+	{ ANIM_STD_CAR_DRIVEBY_RIGHT, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
+	{ ANIM_STD_CAR_LOOKBEHIND, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
+	{ ANIM_STD_BOAT_DRIVE, ASSOC_DELETEFADEDOUT },
+	{ ANIM_STD_GETOUT_RHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_GETOUT_LO_RHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_CAR_CLOSE_RHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_CAR_HOOKERTALK, ASSOC_REPEAT | ASSOC_PARTIAL },
+	{ ANIM_STD_COACH_OPEN_LHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_COACH_OPEN_RHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_COACH_GET_IN_LHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_COACH_GET_IN_RHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_COACH_GET_OUT_LHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_TRAIN_GETIN, ASSOC_PARTIAL },
+	{ ANIM_STD_TRAIN_GETOUT, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_CRAWLOUT_LHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_CRAWLOUT_RHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_VAN_OPEN_DOOR_REAR_LHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_VAN_GET_IN_REAR_LHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_VAN_CLOSE_DOOR_REAR_LHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_VAN_GET_OUT_REAR_LHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_VAN_OPEN_DOOR_REAR_RHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_VAN_GET_IN_REAR_RHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_VAN_CLOSE_DOOR_REAR_RHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_VAN_GET_OUT_REAR_RHS, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_GET_UP, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
+	{ ANIM_STD_GET_UP_LEFT, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
+	{ ANIM_STD_GET_UP_RIGHT, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
+	{ ANIM_STD_GET_UP_FRONT, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
+	{ ANIM_STD_JUMP_LAUNCH, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_JUMP_GLIDE, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
+	{ ANIM_STD_JUMP_LAND, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
+	{ ANIM_STD_FALL, ASSOC_REPEAT | ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
+	{ ANIM_STD_FALL_GLIDE, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
+	{ ANIM_STD_FALL_LAND, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
+	{ ANIM_STD_FALL_COLLAPSE, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
+	{ ANIM_STD_EVADE_STEP, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
+	{ ANIM_STD_EVADE_DIVE, ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION | ASSOC_FRONTAL  },
+	{ ANIM_STD_XPRESS_SCRATCH, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_IDLE  },
+	{ ANIM_STD_ROADCROSS, ASSOC_REPEAT | ASSOC_PARTIAL },
+	{ ANIM_STD_TURN180, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_ARREST, ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
+	{ ANIM_STD_DROWN, ASSOC_PARTIAL },
+	{ ANIM_MEDIC_CPR, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_DUCK_DOWN, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
+	{ ANIM_STD_DUCK_LOW, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
+	{ ANIM_STD_RBLOCK_SHOOT, ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
+	{ ANIM_STD_THROW_UNDER2, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_HANDSUP, ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
+	{ ANIM_STD_HANDSCOWER, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_HAS_TRANSLATION },
+	{ ANIM_STD_PARTIAL_FUCKU, ASSOC_DELETEFADEDOUT | ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL | ASSOC_NOWALK  },
+	{ ANIM_STD_PHONE_IN, ASSOC_PARTIAL },
+	{ ANIM_STD_PHONE_OUT, ASSOC_FADEOUTWHENDONE | ASSOC_PARTIAL },
+	{ ANIM_STD_PHONE_TALK, ASSOC_REPEAT | ASSOC_DELETEFADEDOUT | ASSOC_PARTIAL },
 };
 #ifdef PC_PLAYER_CONTROLS
 AnimAssocDesc aStdAnimDescsSide[] = {
-	{ ANIM_WALK, ASSOC_REPEAT | ASSOC_MOVEMENT | ASSOC_HAS_TRANSLATION | ASSOC_WALK | ASSOC_HAS_X_TRANSLATION },
-	{ ANIM_RUN, ASSOC_REPEAT | ASSOC_MOVEMENT | ASSOC_HAS_TRANSLATION | ASSOC_WALK | ASSOC_HAS_X_TRANSLATION },
-	{ ANIM_SPRINT, ASSOC_REPEAT | ASSOC_MOVEMENT | ASSOC_HAS_TRANSLATION | ASSOC_WALK | ASSOC_HAS_X_TRANSLATION },
-	{ ANIM_IDLE_STANCE, ASSOC_REPEAT },
-	{ ANIM_WALK_START, ASSOC_HAS_TRANSLATION | ASSOC_HAS_X_TRANSLATION },
+	{ ANIM_STD_WALK, ASSOC_REPEAT | ASSOC_MOVEMENT | ASSOC_HAS_TRANSLATION | ASSOC_WALK | ASSOC_HAS_X_TRANSLATION },
+	{ ANIM_STD_RUN, ASSOC_REPEAT | ASSOC_MOVEMENT | ASSOC_HAS_TRANSLATION | ASSOC_WALK | ASSOC_HAS_X_TRANSLATION },
+	{ ANIM_STD_RUNFAST, ASSOC_REPEAT | ASSOC_MOVEMENT | ASSOC_HAS_TRANSLATION | ASSOC_WALK | ASSOC_HAS_X_TRANSLATION },
+	{ ANIM_STD_IDLE, ASSOC_REPEAT },
+	{ ANIM_STD_STARTWALK, ASSOC_HAS_TRANSLATION | ASSOC_HAS_X_TRANSLATION },
 };
 #endif
 char const *aStdAnimations[] = {
diff --git a/src/animation/AnimationId.h b/src/animation/AnimationId.h
index 4b3dd92d..baf6eb33 100644
--- a/src/animation/AnimationId.h
+++ b/src/animation/AnimationId.h
@@ -2,68 +2,82 @@
 
 enum AnimationId
 {
-	ANIM_WALK,
-	ANIM_RUN,
-	ANIM_SPRINT,
-	ANIM_IDLE_STANCE,
-	ANIM_WALK_START,
-	ANIM_RUN_STOP,
-	ANIM_RUN_STOP_R,
-	ANIM_IDLE_CAM,
-	ANIM_IDLE_HBHB,
-	ANIM_IDLE_TIRED,
-	ANIM_IDLE_ARMED,
-	ANIM_IDLE_CHAT,
-	ANIM_IDLE_TAXI,
-	ANIM_KO_SHOT_FRONT1,
-	ANIM_KO_SHOT_FRONT2,
-	ANIM_KO_SHOT_FRONT3,
-	ANIM_KO_SHOT_FRONT4,
-	ANIM_KO_SHOT_FACE,
-	ANIM_KO_SHOT_STOM,
-	ANIM_KO_SHOT_ARML,
-	ANIM_KO_SHOT_ARMR,
-	ANIM_KO_SHOT_LEGL,
-	ANIM_KO_SHOT_LEGR,
-	ANIM_KD_LEFT,
-	ANIM_KD_RIGHT,
-	ANIM_KO_SKID_FRONT,
-	ANIM_KO_SPIN_R, // named left in VC
-	ANIM_KO_SKID_BACK,
-	ANIM_KO_SPIN_L, // named right in VC
-	ANIM_SHOT_FRONT_PARTIAL,
-	ANIM_SHOT_LEFT_PARTIAL,
-	ANIM_SHOT_BACK_PARTIAL,
-	ANIM_SHOT_RIGHT_PARTIAL,
-	ANIM_HIT_FRONT,
-	ANIM_HIT_LEFT,
-	ANIM_HIT_BACK,
-	ANIM_HIT_RIGHT,
-	ANIM_FLOOR_HIT,
+	ANIM_STD_WALK,
+	ANIM_STD_RUN,
+	ANIM_STD_RUNFAST,
+	ANIM_STD_IDLE,
+	ANIM_STD_STARTWALK,
+	ANIM_STD_RUNSTOP1,
+	ANIM_STD_RUNSTOP2,
+	ANIM_STD_IDLE_CAM,
+	ANIM_STD_IDLE_HBHB,
+	ANIM_STD_IDLE_TIRED,
+	ANIM_STD_IDLE_BIGGUN,
+	ANIM_STD_CHAT,
+	ANIM_STD_HAILTAXI,
+	ANIM_STD_KO_FRONT,
+	ANIM_STD_KO_LEFT,
+	ANIM_STD_KO_BACK,
+	ANIM_STD_KO_RIGHT,
+	ANIM_STD_KO_SHOT_FACE,
+	ANIM_STD_KO_SHOT_STOMACH,
+	ANIM_STD_KO_SHOT_ARM_L,
+	ANIM_STD_KO_SHOT_ARM_R,
+	ANIM_STD_KO_SHOT_LEG_L,
+	ANIM_STD_KO_SHOT_LEG_R,
+	ANIM_STD_SPINFORWARD_LEFT,
+	ANIM_STD_SPINFORWARD_RIGHT,
+	ANIM_STD_HIGHIMPACT_FRONT,
+	ANIM_STD_HIGHIMPACT_LEFT,
+	ANIM_STD_HIGHIMPACT_BACK,
+	ANIM_STD_HIGHIMPACT_RIGHT,
+	ANIM_STD_HITBYGUN_FRONT,
+	ANIM_STD_HITBYGUN_LEFT,
+	ANIM_STD_HITBYGUN_BACK,
+	ANIM_STD_HITBYGUN_RIGHT,
+	ANIM_STD_HIT_FRONT,
+	ANIM_STD_HIT_LEFT,
+	ANIM_STD_HIT_BACK,
+	ANIM_STD_HIT_RIGHT,
+	ANIM_STD_HIT_FLOOR,
+
+	/* names made up */
 #if GTA_VERSION <= GTA3_PS2_160
-	ANIM_HIT_BODY,
+	ANIM_STD_HIT_BODY,
 #endif
-	ANIM_HIT_BODYBLOW,
-	ANIM_HIT_CHEST,
-	ANIM_HIT_HEAD,
-	ANIM_HIT_WALK,
-	ANIM_HIT_WALL,
-	ANIM_FLOOR_HIT_F,
-	ANIM_HIT_BEHIND,
-	ANIM_PUNCH_R,
-	ANIM_KICK_FLOOR,
-	ANIM_WEAPON_BAT_H,
-	ANIM_WEAPON_BAT_V,
-	ANIM_WEAPON_HGUN_BODY,
-	ANIM_WEAPON_AK_BODY,
-	ANIM_WEAPON_PUMP,
-	ANIM_WEAPON_SNIPER,
-	ANIM_WEAPON_THROW,
-	ANIM_WEAPON_THROWU,
-	ANIM_WEAPON_START_THROW,
-	ANIM_BOMBER,
-	ANIM_HGUN_RELOAD,
-	ANIM_AK_RELOAD,
+	ANIM_STD_HIT_BODYBLOW,
+	ANIM_STD_HIT_CHEST,
+	ANIM_STD_HIT_HEAD,
+	ANIM_STD_HIT_WALK,
+	/**/
+
+	ANIM_STD_HIT_WALL,
+	ANIM_STD_HIT_FLOOR_FRONT,
+	ANIM_STD_HIT_BEHIND,
+	ANIM_STD_PUNCH,
+	ANIM_STD_KICKGROUND,
+
+	/* names made up */
+	ANIM_STD_WEAPON_BAT_H,
+	ANIM_STD_WEAPON_BAT_V,
+	ANIM_STD_WEAPON_HGUN_BODY,
+	ANIM_STD_WEAPON_AK_BODY,
+	ANIM_STD_WEAPON_PUMP,
+	ANIM_STD_WEAPON_SNIPER,
+	ANIM_STD_WEAPON_THROW,
+	/**/
+
+	ANIM_STD_THROW_UNDER,
+
+	/* names made up */
+	ANIM_STD_START_THROW,
+	/**/
+
+	ANIM_STD_DETONATE,
+
+	/* names made up */
+	ANIM_STD_HGUN_RELOAD,
+	ANIM_STD_AK_RELOAD,
 #ifdef PC_PLAYER_CONTROLS
 	// maybe wrong define, but unused anyway
 	ANIM_FPS_PUNCH,
@@ -74,113 +88,123 @@ enum AnimationId
 	ANIM_FPS_M16,
 	ANIM_FPS_ROCKET,
 #endif
-	ANIM_FIGHT_IDLE,
-	ANIM_FIGHT2_IDLE,
-	ANIM_FIGHT_SH_F,
-	ANIM_FIGHT_BODYBLOW,
-	ANIM_FIGHT_HEAD,
-	ANIM_FIGHT_KICK,
-	ANIM_FIGHT_KNEE,
-	ANIM_FIGHT_LHOOK,
-	ANIM_FIGHT_PUNCH,
-	ANIM_FIGHT_ROUNDHOUSE,
-	ANIM_FIGHT_LONGKICK,
-	ANIM_FIGHT_PPUNCH,
-	ANIM_CAR_JACKED_RHS,
-	ANIM_CAR_LJACKED_RHS,
-	ANIM_CAR_JACKED_LHS,
-	ANIM_CAR_LJACKED_LHS,
-	ANIM_CAR_QJACK,
-	ANIM_CAR_QJACKED,
-	ANIM_CAR_ALIGN_LHS,
-	ANIM_CAR_ALIGNHI_LHS,
-	ANIM_CAR_OPEN_LHS,
-	ANIM_CAR_DOORLOCKED_LHS,
-	ANIM_CAR_PULLOUT_LHS,
-	ANIM_CAR_PULLOUT_LOW_LHS,
-	ANIM_CAR_GETIN_LHS,
-	ANIM_CAR_GETIN_LOW_LHS,
-	ANIM_CAR_CLOSEDOOR_LHS,
-	ANIM_CAR_CLOSEDOOR_LOW_LHS,
-	ANIM_CAR_ROLLDOOR,
-	ANIM_CAR_ROLLDOOR_LOW,
-	ANIM_CAR_GETOUT_LHS,
-	ANIM_CAR_GETOUT_LOW_LHS,
-	ANIM_CAR_CLOSE_LHS,
-	ANIM_CAR_ALIGN_RHS,
-	ANIM_CAR_ALIGNHI_RHS,
-	ANIM_CAR_OPEN_RHS,
-	ANIM_CAR_DOORLOCKED_RHS,
-	ANIM_CAR_PULLOUT_RHS,
-	ANIM_CAR_PULLOUT_LOW_RHS,
-	ANIM_CAR_GETIN_RHS,
-	ANIM_CAR_GETIN_LOW_RHS,
-	ANIM_CAR_CLOSEDOOR_RHS,
-	ANIM_CAR_CLOSEDOOR_LOW_RHS,
-	ANIM_CAR_SHUFFLE_RHS,
-	ANIM_CAR_LSHUFFLE_RHS,
-	ANIM_CAR_SIT,
-	ANIM_CAR_LSIT,
-	ANIM_CAR_SITP,
-	ANIM_CAR_SITPLO,
-	ANIM_DRIVE_L,
-	ANIM_DRIVE_R,
-	ANIM_DRIVE_LOW_L,
-	ANIM_DRIVE_LOW_R,
-	ANIM_DRIVEBY_L,
-	ANIM_DRIVEBY_R,
-	ANIM_CAR_LB,
-	ANIM_DRIVE_BOAT,
-	ANIM_CAR_GETOUT_RHS,
-	ANIM_CAR_GETOUT_LOW_RHS,
-	ANIM_CAR_CLOSE_RHS,
-	ANIM_CAR_HOOKERTALK,
-	ANIM_COACH_OPEN_L,
-	ANIM_COACH_OPEN_R,
-	ANIM_COACH_IN_L,
-	ANIM_COACH_IN_R,
-	ANIM_COACH_OUT_L,
-	ANIM_TRAIN_GETIN,
-	ANIM_TRAIN_GETOUT,
-	ANIM_CAR_CRAWLOUT_RHS,
-	ANIM_CAR_CRAWLOUT_RHS2,
-	ANIM_VAN_OPEN_L,
-	ANIM_VAN_GETIN_L,
-	ANIM_VAN_CLOSE_L,
-	ANIM_VAN_GETOUT_L,
-	ANIM_VAN_OPEN,
-	ANIM_VAN_GETIN,
-	ANIM_VAN_CLOSE,
-	ANIM_VAN_GETOUT,
-	ANIM_GETUP1,
-	ANIM_GETUP2,
-	ANIM_GETUP3,
-	ANIM_GETUP_FRONT,
-	ANIM_JUMP_LAUNCH,
-	ANIM_JUMP_GLIDE,
-	ANIM_JUMP_LAND,
-	ANIM_FALL_FALL,
-	ANIM_FALL_GLIDE,
-	ANIM_FALL_LAND,
-	ANIM_FALL_COLLAPSE,
-	ANIM_EV_STEP,
-	ANIM_EV_DIVE,
-	ANIM_XPRESS_SCRATCH,
-	ANIM_ROAD_CROSS,
-	ANIM_TURN_180,
-	ANIM_ARREST_GUN,
-	ANIM_DROWN,
-	ANIM_CPR,
-	ANIM_DUCK_DOWN,
-	ANIM_DUCK_LOW,
-	ANIM_RBLOCK_CSHOOT,
-	ANIM_WEAPON_THROWU2,
-	ANIM_HANDSUP,
-	ANIM_HANDSCOWER,
-	ANIM_FUCKU,
-	ANIM_PHONE_IN,
-	ANIM_PHONE_OUT,
-	ANIM_PHONE_TALK,
+	/**/
+
+	ANIM_STD_FIGHT_IDLE,
+	ANIM_STD_FIGHT_2IDLE,
+	ANIM_STD_FIGHT_SHUFFLE_F,
+
+	/* names made up */
+	ANIM_STD_FIGHT_BODYBLOW,
+	ANIM_STD_FIGHT_HEAD,
+	ANIM_STD_FIGHT_KICK,
+	ANIM_STD_FIGHT_KNEE,
+	ANIM_STD_FIGHT_LHOOK,
+	ANIM_STD_FIGHT_PUNCH,
+	ANIM_STD_FIGHT_ROUNDHOUSE,
+	ANIM_STD_FIGHT_LONGKICK,
+	/**/
+
+	ANIM_STD_PARTIAL_PUNCH,
+	ANIM_STD_JACKEDCAR_RHS,
+	ANIM_STD_JACKEDCAR_LO_RHS,
+	ANIM_STD_JACKEDCAR_LHS,
+	ANIM_STD_JACKEDCAR_LO_LHS,
+	ANIM_STD_QUICKJACK,
+	ANIM_STD_QUICKJACKED,
+	ANIM_STD_CAR_ALIGN_DOOR_LHS,
+	ANIM_STD_CAR_ALIGNHI_DOOR_LHS,
+	ANIM_STD_CAR_OPEN_DOOR_LHS,
+	ANIM_STD_CARDOOR_LOCKED_LHS,
+	ANIM_STD_CAR_PULL_OUT_PED_LHS,
+	ANIM_STD_CAR_PULL_OUT_PED_LO_LHS,
+	ANIM_STD_CAR_GET_IN_LHS,
+	ANIM_STD_CAR_GET_IN_LO_LHS,
+	ANIM_STD_CAR_CLOSE_DOOR_LHS,
+	ANIM_STD_CAR_CLOSE_DOOR_LO_LHS,
+	ANIM_STD_CAR_CLOSE_DOOR_ROLLING_LHS,
+	ANIM_STD_CAR_CLOSE_DOOR_ROLLING_LO_LHS,
+	ANIM_STD_GETOUT_LHS,
+	ANIM_STD_GETOUT_LO_LHS,
+	ANIM_STD_CAR_CLOSE_LHS,
+	ANIM_STD_CAR_ALIGN_DOOR_RHS,
+	ANIM_STD_CAR_ALIGNHI_DOOR_RHS,
+	ANIM_STD_CAR_OPEN_DOOR_RHS,
+	ANIM_STD_CARDOOR_LOCKED_RHS,
+	ANIM_STD_CAR_PULL_OUT_PED_RHS,
+	ANIM_STD_CAR_PULL_OUT_PED_LO_RHS,
+	ANIM_STD_CAR_GET_IN_RHS,
+	ANIM_STD_CAR_GET_IN_LO_RHS,
+	ANIM_STD_CAR_CLOSE_DOOR_RHS,
+	ANIM_STD_CAR_CLOSE_DOOR_LO_RHS,
+	ANIM_STD_CAR_SHUFFLE_RHS,
+	ANIM_STD_CAR_SHUFFLE_LO_RHS,
+	ANIM_STD_CAR_SIT,
+	ANIM_STD_CAR_SIT_LO,
+	ANIM_STD_CAR_SIT_P,
+	ANIM_STD_CAR_SIT_P_LO,
+	ANIM_STD_CAR_DRIVE_LEFT,
+	ANIM_STD_CAR_DRIVE_RIGHT,
+	ANIM_STD_CAR_DRIVE_LEFT_LO,
+	ANIM_STD_CAR_DRIVE_RIGHT_LO,
+	ANIM_STD_CAR_DRIVEBY_LEFT,
+	ANIM_STD_CAR_DRIVEBY_RIGHT,
+	ANIM_STD_CAR_LOOKBEHIND,
+	ANIM_STD_BOAT_DRIVE,
+	ANIM_STD_GETOUT_RHS,
+	ANIM_STD_GETOUT_LO_RHS,
+	ANIM_STD_CAR_CLOSE_RHS,
+	ANIM_STD_CAR_HOOKERTALK,
+	ANIM_STD_COACH_OPEN_LHS,
+	ANIM_STD_COACH_OPEN_RHS,
+	ANIM_STD_COACH_GET_IN_LHS,
+	ANIM_STD_COACH_GET_IN_RHS,
+	ANIM_STD_COACH_GET_OUT_LHS,
+	ANIM_STD_TRAIN_GETIN,
+	ANIM_STD_TRAIN_GETOUT,
+	ANIM_STD_CRAWLOUT_LHS,
+	ANIM_STD_CRAWLOUT_RHS,
+	ANIM_STD_VAN_OPEN_DOOR_REAR_LHS,
+	ANIM_STD_VAN_GET_IN_REAR_LHS,
+	ANIM_STD_VAN_CLOSE_DOOR_REAR_LHS,
+	ANIM_STD_VAN_GET_OUT_REAR_LHS,
+	ANIM_STD_VAN_OPEN_DOOR_REAR_RHS,
+	ANIM_STD_VAN_GET_IN_REAR_RHS,
+	ANIM_STD_VAN_CLOSE_DOOR_REAR_RHS,
+	ANIM_STD_VAN_GET_OUT_REAR_RHS,
+	ANIM_STD_GET_UP,
+	ANIM_STD_GET_UP_LEFT,
+	ANIM_STD_GET_UP_RIGHT,
+	ANIM_STD_GET_UP_FRONT,
+	ANIM_STD_JUMP_LAUNCH,
+	ANIM_STD_JUMP_GLIDE,
+	ANIM_STD_JUMP_LAND,
+	ANIM_STD_FALL,
+	ANIM_STD_FALL_GLIDE,
+	ANIM_STD_FALL_LAND,
+	ANIM_STD_FALL_COLLAPSE,
+	ANIM_STD_EVADE_STEP,
+	ANIM_STD_EVADE_DIVE,
+	ANIM_STD_XPRESS_SCRATCH,
+	ANIM_STD_ROADCROSS,
+	ANIM_STD_TURN180,
+	ANIM_STD_ARREST,
+	ANIM_STD_DROWN,
+	ANIM_MEDIC_CPR,
+	ANIM_STD_DUCK_DOWN,
+	ANIM_STD_DUCK_LOW,
+	ANIM_STD_RBLOCK_SHOOT,
+
+	/* names made up */
+	ANIM_STD_THROW_UNDER2,
+	/**/
+
+	ANIM_STD_HANDSUP,
+	ANIM_STD_HANDSCOWER,
+	ANIM_STD_PARTIAL_FUCKU,
+	ANIM_STD_PHONE_IN,
+	ANIM_STD_PHONE_OUT,
+	ANIM_STD_PHONE_TALK,
 
-	NUM_ANIMS
+	ANIM_STD_NUM
 };
\ No newline at end of file
diff --git a/src/control/Phones.cpp b/src/control/Phones.cpp
index f649d435..ef7ecead 100644
--- a/src/control/Phones.cpp
+++ b/src/control/Phones.cpp
@@ -58,9 +58,9 @@ CPhoneInfo::Update(void)
 		TheCamera.SetWideScreenOff();
 		pPhoneDisplayingMessages = nil;
 		bDisplayingPhoneMessage = false;
-		CAnimBlendAssociation *talkAssoc = RpAnimBlendClumpGetAssociation(player->GetClump(), ANIM_PHONE_TALK);
+		CAnimBlendAssociation *talkAssoc = RpAnimBlendClumpGetAssociation(player->GetClump(), ANIM_STD_PHONE_TALK);
 		if (talkAssoc && talkAssoc->blendAmount > 0.5f) {
-			CAnimBlendAssociation *endAssoc = CAnimManager::BlendAnimation(player->GetClump(), ASSOCGRP_STD, ANIM_PHONE_OUT, 8.0f);
+			CAnimBlendAssociation *endAssoc = CAnimManager::BlendAnimation(player->GetClump(), ASSOCGRP_STD, ANIM_STD_PHONE_OUT, 8.0f);
 			endAssoc->flags &= ~ASSOC_DELETEFADEDOUT;
 			endAssoc->SetFinishCallback(PhonePutDownCB, player);
 		} else {
@@ -117,7 +117,7 @@ CPhoneInfo::Update(void)
 								CPad::GetPad(0)->SetDisablePlayerControls(PLAYERCONTROL_PHONE);
 								TheCamera.SetWideScreenOn();
 								playerInfo->MakePlayerSafe(true);
-								CAnimBlendAssociation *phonePickAssoc = CAnimManager::BlendAnimation(player->GetClump(), ASSOCGRP_STD, ANIM_PHONE_IN, 4.0f);
+								CAnimBlendAssociation *phonePickAssoc = CAnimManager::BlendAnimation(player->GetClump(), ASSOCGRP_STD, ANIM_STD_PHONE_IN, 4.0f);
 								phonePickAssoc->SetFinishCallback(PhonePickUpCB, &m_aPhones[phoneId]);
 								bPickingUpPhone = true;
 								pCallBackPed = player;
@@ -442,10 +442,10 @@ PhonePickUpCB(CAnimBlendAssociation *assoc, void *arg)
 
 	CPed *ped = CPhoneInfo::pCallBackPed;
 	ped->m_nMoveState = PEDMOVE_STILL;
-	CAnimManager::BlendAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_IDLE_STANCE, 8.0f);
+	CAnimManager::BlendAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_STD_IDLE, 8.0f);
 
 	if (assoc->blendAmount > 0.5f && ped)
-		CAnimManager::BlendAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_PHONE_TALK, 8.0f);
+		CAnimManager::BlendAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_STD_PHONE_TALK, 8.0f);
 
 	CPhoneInfo::pCallBackPed = nil;
 }
diff --git a/src/control/Replay.cpp b/src/control/Replay.cpp
index 2dd66333..d8b15385 100644
--- a/src/control/Replay.cpp
+++ b/src/control/Replay.cpp
@@ -457,7 +457,7 @@ void CReplay::StoreDetailedPedAnimation(CPed *ped, CStoredDetailedAnimationState
 				state->aFunctionCallbackID[i] = 0;
 			}
 		}else{
-			state->aAnimId[i] = NUM_ANIMS;
+			state->aAnimId[i] = ANIM_STD_NUM;
 			state->aCurTime[i] = 0;
 			state->aSpeed[i] = 85;
 			state->aFunctionCallbackID[i] = 0;
@@ -484,7 +484,7 @@ void CReplay::StoreDetailedPedAnimation(CPed *ped, CStoredDetailedAnimationState
 			}
 		}
 		else {
-			state->aAnimId2[i] = NUM_ANIMS;
+			state->aAnimId2[i] = ANIM_STD_NUM;
 			state->aCurTime2[i] = 0;
 			state->aSpeed2[i] = 85;
 			state->aFunctionCallbackID2[i] = 0;
@@ -558,7 +558,7 @@ void CReplay::RetrievePedAnimation(CPed *ped, CStoredAnimationState *state)
 		float time = state->partAnimTime * 4.0f / 255.0f;
 		float speed = state->partAnimSpeed * 3.0f / 255.0f;
 		float blend = state->partBlendAmount * 2.0f / 255.0f;
-		if (blend > 0.0f && state->partAnimId != ANIM_IDLE_STANCE){
+		if (blend > 0.0f && state->partAnimId != ANIM_STD_IDLE){
 			CAnimBlendAssociation* anim3 = CAnimManager::BlendAnimation(
 				(RpClump*)ped->m_rwObject, ASSOCGRP_STD, (AnimationId)state->partAnimId, 1000.0f);
 			anim3->SetCurrentTime(time);
@@ -578,7 +578,7 @@ void CReplay::RetrieveDetailedPedAnimation(CPed *ped, CStoredDetailedAnimationSt
 		assoc->SetBlend(0.0f, -1.0f);
 #endif
 	for (int i = 0; i < NUM_MAIN_ANIMS_IN_REPLAY; i++) {
-		if (state->aAnimId[i] == NUM_ANIMS)
+		if (state->aAnimId[i] == ANIM_STD_NUM)
 			continue;
 #ifdef FIX_REPLAY_BUGS
 		CAnimBlendAssociation* anim = CAnimManager::AddAnimation(ped->GetClump(),
@@ -607,7 +607,7 @@ void CReplay::RetrieveDetailedPedAnimation(CPed *ped, CStoredDetailedAnimationSt
 			anim->SetDeleteCallback(FindCBFunction(callback & 0x7F), ped);
 	}
 	for (int i = 0; i < NUM_PARTIAL_ANIMS_IN_REPLAY; i++) {
-		if (state->aAnimId2[i] == NUM_ANIMS)
+		if (state->aAnimId2[i] == ANIM_STD_NUM)
 			continue;
 #ifdef FIX_REPLAY_BUGS
 		CAnimBlendAssociation* anim = CAnimManager::AddAnimation(ped->GetClump(),
diff --git a/src/control/Script.cpp b/src/control/Script.cpp
index e70bd508..5598f3c9 100644
--- a/src/control/Script.cpp
+++ b/src/control/Script.cpp
@@ -4266,7 +4266,7 @@ int8 CRunningScript::ProcessCommands200To299(int32 command)
 #ifdef FIX_BUGS
 		AnimationId anim = pVehicle->GetDriverAnim();
 #else
-		AnimationId anim = pVehicle->bLowVehicle ? ANIM_CAR_LSIT : ANIM_CAR_SIT;
+		AnimationId anim = pVehicle->bLowVehicle ? ANIM_STD_CAR_SIT_LO : ANIM_STD_CAR_SIT;
 #endif
 		pPed->m_pVehicleAnim = CAnimManager::BlendAnimation(pPed->GetClump(), ASSOCGRP_STD, anim, 100.0f);
 		pPed->StopNonPartialAnims();
@@ -4309,7 +4309,7 @@ int8 CRunningScript::ProcessCommands200To299(int32 command)
 			pPlayer->m_pPed->m_pVehicleAnim->blendDelta = -1000.0f;
 		pPlayer->m_pPed->m_pVehicleAnim = nil;
 		pPlayer->m_pPed->SetMoveState(PEDMOVE_NONE);
-		CAnimManager::BlendAnimation(pPlayer->m_pPed->GetClump(), pPlayer->m_pPed->m_animGroup, ANIM_IDLE_STANCE, 100.0f);
+		CAnimManager::BlendAnimation(pPlayer->m_pPed->GetClump(), pPlayer->m_pPed->m_animGroup, ANIM_STD_IDLE, 100.0f);
 		pPlayer->m_pPed->RestartNonPartialAnims();
 		AudioManager.PlayerJustLeftCar();
 		pos.z += pPlayer->m_pPed->GetDistanceFromCentreOfMassToBaseOfModel();
diff --git a/src/control/Script2.cpp b/src/control/Script2.cpp
index 9329b3bc..210b9327 100644
--- a/src/control/Script2.cpp
+++ b/src/control/Script2.cpp
@@ -913,7 +913,7 @@ int8 CRunningScript::ProcessCommands400To499(int32 command)
 			if (strcmp(m_abScriptName, "camera") == 0){
 				pPlayer->m_pPed->SetMoveSpeed(0.0f, 0.0f, 0.0f);
 				pPlayer->m_pPed->SetTurnSpeed(0.0f, 0.0f, 0.0f);
-				CAnimManager::BlendAnimation((RpClump*)pPlayer->m_pPed->m_rwObject, pPlayer->m_pPed->m_animGroup, ANIM_IDLE_STANCE, 1000.0f);
+				CAnimManager::BlendAnimation((RpClump*)pPlayer->m_pPed->m_rwObject, pPlayer->m_pPed->m_animGroup, ANIM_STD_IDLE, 1000.0f);
 			}
 		}
 		return 0;
diff --git a/src/control/Script3.cpp b/src/control/Script3.cpp
index f49835db..ac88347b 100644
--- a/src/control/Script3.cpp
+++ b/src/control/Script3.cpp
@@ -417,7 +417,7 @@ int8 CRunningScript::ProcessCommands500To599(int32 command)
 				pPed->FlagToDestroyWhenNextProcessed();
 		}
 		else {
-			pPed->SetDie(ANIM_KO_SHOT_FRONT1, 4.0f, 0.0f);
+			pPed->SetDie(ANIM_STD_KO_FRONT, 4.0f, 0.0f);
 		}
 		return 0;
 	}
diff --git a/src/control/Script4.cpp b/src/control/Script4.cpp
index 40f9f2f1..93956ea2 100644
--- a/src/control/Script4.cpp
+++ b/src/control/Script4.cpp
@@ -68,7 +68,7 @@ int8 CRunningScript::ProcessCommands800To899(int32 command)
 			pPed->ApplyHeadShot(WEAPONTYPE_SNIPERRIFLE, pPed->GetNodePosition(PED_HEAD), true);
 		}
 		else {
-			pPed->SetDie(ANIM_KO_SHOT_FRONT1, 4.0f, 0.0f);
+			pPed->SetDie(ANIM_STD_KO_FRONT, 4.0f, 0.0f);
 		}
 		return 0;
 	}
@@ -81,7 +81,7 @@ int8 CRunningScript::ProcessCommands800To899(int32 command)
 			pPed->ApplyHeadShot(WEAPONTYPE_SNIPERRIFLE, pPed->GetNodePosition(PED_HEAD), true);
 		}
 		else {
-			pPed->SetDie(ANIM_KO_SHOT_FRONT1, 4.0f, 0.0f);
+			pPed->SetDie(ANIM_STD_KO_FRONT, 4.0f, 0.0f);
 		}
 		return 0;
 	}
@@ -793,7 +793,7 @@ int8 CRunningScript::ProcessCommands800To899(int32 command)
 		pPed->m_pVehicleAnim = nil;
 		pPed->RestartNonPartialAnims();
 		pPed->SetMoveState(PEDMOVE_NONE);
-		CAnimManager::BlendAnimation(pPed->GetClump(), pPed->m_animGroup, ANIM_IDLE_STANCE, 100.0f);
+		CAnimManager::BlendAnimation(pPed->GetClump(), pPed->m_animGroup, ANIM_STD_IDLE, 100.0f);
 		pos.z += pPed->GetDistanceFromCentreOfMassToBaseOfModel();
 		pPed->Teleport(pos);
 		CTheScripts::ClearSpaceForMissionEntity(pos, pPed);
diff --git a/src/control/Script5.cpp b/src/control/Script5.cpp
index b54d425c..464a77d8 100644
--- a/src/control/Script5.cpp
+++ b/src/control/Script5.cpp
@@ -2450,10 +2450,10 @@ bool CTheScripts::IsPlayerStopped(CPlayerInfo* pPlayer)
 	CPed* pPed = pPlayer->m_pPed;
 	if (pPed->bInVehicle)
 		return IsVehicleStopped(pPed->m_pMyVehicle);
-	if (RpAnimBlendClumpGetAssociation(pPed->GetClump(), ANIM_RUN_STOP) ||
-		RpAnimBlendClumpGetAssociation(pPed->GetClump(), ANIM_RUN_STOP_R) ||
-		RpAnimBlendClumpGetAssociation(pPed->GetClump(), ANIM_JUMP_LAUNCH) ||
-		RpAnimBlendClumpGetAssociation(pPed->GetClump(), ANIM_JUMP_GLIDE))
+	if (RpAnimBlendClumpGetAssociation(pPed->GetClump(), ANIM_STD_RUNSTOP1) ||
+		RpAnimBlendClumpGetAssociation(pPed->GetClump(), ANIM_STD_RUNSTOP2) ||
+		RpAnimBlendClumpGetAssociation(pPed->GetClump(), ANIM_STD_JUMP_LAUNCH) ||
+		RpAnimBlendClumpGetAssociation(pPed->GetClump(), ANIM_STD_JUMP_GLIDE))
 		return false;
 	return pPed->m_nMoveState == PEDMOVE_NONE || pPed->m_nMoveState == PEDMOVE_STILL;
 }
diff --git a/src/core/AnimViewer.cpp b/src/core/AnimViewer.cpp
index a888d528..946693a7 100644
--- a/src/core/AnimViewer.cpp
+++ b/src/core/AnimViewer.cpp
@@ -230,7 +230,7 @@ CAnimViewer::Update(void)
 	if (modelInfo->GetModelType() == MITYPE_PED) {
 		int animGroup = ((CPedModelInfo*)modelInfo)->m_animGroup;
 
-		if (animId > ANIM_IDLE_STANCE)
+		if (animId > ANIM_STD_IDLE)
 			animGroup = ASSOCGRP_STD;
 
 		if (reloadIFP) {
@@ -318,14 +318,14 @@ CAnimViewer::Update(void)
 				CMessages::AddMessage(gUString, 1000, 0);
 
 			} else if (pad->GetCircleJustDown()) {
-				PlayAnimation(pTarget->GetClump(), animGroup, ANIM_IDLE_STANCE);
+				PlayAnimation(pTarget->GetClump(), animGroup, ANIM_STD_IDLE);
 				AsciiToUnicode("Idle animation playing", gUString);
 				CMessages::AddMessage(gUString, 1000, 0);
 
 			} else if (pad->GetDPadUpJustDown()) {
 				animId--;
 				if (animId < 0) {
-					animId = NUM_ANIMS - 1;
+					animId = ANIM_STD_NUM - 1;
 				}
 				PlayAnimation(pTarget->GetClump(), animGroup, (AnimationId)animId);
 
@@ -334,7 +334,7 @@ CAnimViewer::Update(void)
 				CMessages::AddMessage(gUString, 1000, 0);
 
 			} else if (pad->GetDPadDownJustDown()) {
-				animId = (animId == (NUM_ANIMS - 1) ? 0 : animId + 1);
+				animId = (animId == (ANIM_STD_NUM - 1) ? 0 : animId + 1);
 				PlayAnimation(pTarget->GetClump(), animGroup, (AnimationId)animId);
 
 				sprintf(gString, "Current anim: %d", animId);
diff --git a/src/core/Cam.cpp b/src/core/Cam.cpp
index f43ff57a..2a32ed1f 100644
--- a/src/core/Cam.cpp
+++ b/src/core/Cam.cpp
@@ -1644,10 +1644,10 @@ CCam::Process_FollowPedWithMouse(const CVector &CameraTarget, float TargetOrient
 
 	if(CamTargetEntity->m_rwObject){
 		// what's going on here?
-		if(RpAnimBlendClumpGetAssociation(CamTargetEntity->GetClump(), ANIM_WEAPON_PUMP) ||
-		   RpAnimBlendClumpGetAssociation(CamTargetEntity->GetClump(), ANIM_WEAPON_THROW) ||
-		   RpAnimBlendClumpGetAssociation(CamTargetEntity->GetClump(), ANIM_WEAPON_THROWU) ||
-		   RpAnimBlendClumpGetAssociation(CamTargetEntity->GetClump(), ANIM_WEAPON_START_THROW)){
+		if(RpAnimBlendClumpGetAssociation(CamTargetEntity->GetClump(), ANIM_STD_WEAPON_PUMP) ||
+		   RpAnimBlendClumpGetAssociation(CamTargetEntity->GetClump(), ANIM_STD_WEAPON_THROW) ||
+		   RpAnimBlendClumpGetAssociation(CamTargetEntity->GetClump(), ANIM_STD_THROW_UNDER) ||
+		   RpAnimBlendClumpGetAssociation(CamTargetEntity->GetClump(), ANIM_STD_START_THROW)){
 			CPed *player = FindPlayerPed();
 			float PlayerDist = (Source - player->GetPosition()).Magnitude();
 			if(PlayerDist < 2.75f)
diff --git a/src/core/PlayerInfo.cpp b/src/core/PlayerInfo.cpp
index 1af8f924..bd6feeed 100644
--- a/src/core/PlayerInfo.cpp
+++ b/src/core/PlayerInfo.cpp
@@ -155,8 +155,8 @@ CPlayerInfo::Process(void)
 							m_pPed->SetPedState(PED_IDLE);
 							m_pPed->SetMoveState(PEDMOVE_STILL);
 							CPed::PedSetOutCarCB(0, m_pPed);
-							CAnimManager::BlendAnimation(m_pPed->GetClump(), m_pPed->m_animGroup, ANIM_IDLE_STANCE, 100.0f);
-							CAnimManager::BlendAnimation(m_pPed->GetClump(), ASSOCGRP_STD, ANIM_FALL_LAND, 100.0f);
+							CAnimManager::BlendAnimation(m_pPed->GetClump(), m_pPed->m_animGroup, ANIM_STD_IDLE, 100.0f);
+							CAnimManager::BlendAnimation(m_pPed->GetClump(), ASSOCGRP_STD, ANIM_STD_FALL_LAND, 100.0f);
 							m_pPed->SetPosition(sth);
 							m_pPed->SetMoveState(PEDMOVE_STILL);
 							m_pPed->m_vecMoveSpeed = veh->m_vecMoveSpeed;
diff --git a/src/core/World.cpp b/src/core/World.cpp
index 0874b680..90d73b09 100644
--- a/src/core/World.cpp
+++ b/src/core/World.cpp
@@ -2123,7 +2123,7 @@ CWorld::TriggerExplosionSectorList(CPtrList &list, const CVector &position, floa
 						                    PEDPIECE_TORSO, direction);
 						if(pPed->m_nPedState != PED_DIE)
 							pPed->SetFall(2000,
-							              (AnimationId)(direction + ANIM_KO_SKID_FRONT), 0);
+							              (AnimationId)(direction + ANIM_STD_HIGHIMPACT_FRONT), 0);
 						if(pCreator && pCreator->IsPed()) {
 							eEventType eventType = EVENT_SHOOT_PED;
 							if(pPed->m_nPedType == PEDTYPE_COP) eventType = EVENT_SHOOT_COP;
diff --git a/src/peds/CopPed.cpp b/src/peds/CopPed.cpp
index 29612ccf..44e3baf0 100644
--- a/src/peds/CopPed.cpp
+++ b/src/peds/CopPed.cpp
@@ -239,9 +239,9 @@ CCopPed::ArrestPlayer(void)
 
 		if (suspect && (suspect->m_nPedState == PED_ARRESTED || suspect->DyingOrDead() || suspect->EnteringCar())) {
 
-			CAnimBlendAssociation *arrestAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_ARREST_GUN);
+			CAnimBlendAssociation *arrestAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_ARREST);
 			if (!arrestAssoc || arrestAssoc->blendDelta < 0.0f)
-				CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_ARREST_GUN, 4.0f);
+				CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_ARREST, 4.0f);
 
 			CVector suspMidPos;
 			suspect->m_pedIK.GetComponentPosition(suspMidPos, PED_MID);
@@ -401,7 +401,7 @@ CCopPed::CopAI(void)
 				if (m_nPedState != PED_ATTACK && m_nPedState != PED_FIGHT && !m_bZoneDisabled) {
 					CVector targetDist = playerOrHisVeh->GetPosition() - GetPosition();
 					if (m_fDistanceToTarget > 30.0f) {
-						CAnimBlendAssociation* crouchShootAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_RBLOCK_CSHOOT);
+						CAnimBlendAssociation* crouchShootAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_RBLOCK_SHOOT);
 						if (crouchShootAssoc)
 							crouchShootAssoc->blendDelta = -1000.0f;
 
diff --git a/src/peds/EmergencyPed.cpp b/src/peds/EmergencyPed.cpp
index 9f87c12b..d8c8309e 100644
--- a/src/peds/EmergencyPed.cpp
+++ b/src/peds/EmergencyPed.cpp
@@ -317,7 +317,7 @@ CEmergencyPed::MedicAI(void)
 						m_nEmergencyPedState = EMERGENCY_PED_STAND_STILL;
 					} else {
 						m_nEmergencyPedState = EMERGENCY_PED_FACE_TO_PATIENT;
-						m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_CPR, 4.0f);
+						m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_MEDIC_CPR, 4.0f);
 						bIsDucking = true;
 					}
 					SetLookTimer(2000);
diff --git a/src/peds/Ped.cpp b/src/peds/Ped.cpp
index 87e77ef3..e0d60304 100644
--- a/src/peds/Ped.cpp
+++ b/src/peds/Ped.cpp
@@ -329,7 +329,7 @@ CPed::SetModelIndex(uint32 mi)
 	SetPedStats(modelInfo->m_pedStatType);
 	m_headingRate = m_pedStats->m_headingChangeRate;
 	m_animGroup = (AssocGroupId) modelInfo->m_animGroup;
-	CAnimManager::AddAnimation(GetClump(), m_animGroup, ANIM_IDLE_STANCE);
+	CAnimManager::AddAnimation(GetClump(), m_animGroup, ANIM_STD_IDLE);
 
 	(*RPANIMBLENDCLUMPDATA(m_rwObject))->velocity2d = &m_vecAnimMoveDelta;
 
@@ -496,30 +496,30 @@ CPed::SetMoveAnim(void)
 
 	CAnimBlendAssociation *animAssoc = RpAnimBlendClumpGetFirstAssociation(GetClump(), ASSOC_BLOCK);
 	if (!animAssoc) {
-		CAnimBlendAssociation *fightIdleAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_FIGHT_IDLE);
+		CAnimBlendAssociation *fightIdleAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_FIGHT_IDLE);
 		animAssoc = fightIdleAssoc;
 		if (fightIdleAssoc && m_nPedState == PED_FIGHT)
 			return;
 
 		if (fightIdleAssoc) {
-			CAnimBlendAssociation *idleAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_IDLE_STANCE);
+			CAnimBlendAssociation *idleAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_IDLE);
 			if (!idleAssoc || idleAssoc->blendDelta <= 0.0f) {
 				animAssoc->flags |= ASSOC_DELETEFADEDOUT;
-				animAssoc = CAnimManager::BlendAnimation(GetClump(), animGroupToUse, ANIM_IDLE_STANCE, 8.0f);
+				animAssoc = CAnimManager::BlendAnimation(GetClump(), animGroupToUse, ANIM_STD_IDLE, 8.0f);
 			}
 		}
 	}
 	if (!animAssoc) {
-		animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_IDLE_TIRED);
+		animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_IDLE_TIRED);
 		if (animAssoc)
 			if (m_nWaitState == WAITSTATE_STUCK || m_nWaitState == WAITSTATE_FINISH_FLEE)
 				return;
 
 		if (animAssoc) {
-			CAnimBlendAssociation *idleAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_IDLE_STANCE);
+			CAnimBlendAssociation *idleAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_IDLE);
 			if (!idleAssoc || idleAssoc->blendDelta <= 0.0f) {
 				animAssoc->flags |= ASSOC_DELETEFADEDOUT;
-				animAssoc = CAnimManager::BlendAnimation(GetClump(), animGroupToUse, ANIM_IDLE_STANCE, 4.0f);
+				animAssoc = CAnimManager::BlendAnimation(GetClump(), animGroupToUse, ANIM_STD_IDLE, 4.0f);
 			}
 		}
 	}
@@ -541,20 +541,20 @@ CPed::SetMoveAnim(void)
 
 		switch (m_nMoveState) {
 			case PEDMOVE_STILL:
-				animAssoc = CAnimManager::BlendAnimation(GetClump(), animGroupToUse, ANIM_IDLE_STANCE, 4.0f);
+				animAssoc = CAnimManager::BlendAnimation(GetClump(), animGroupToUse, ANIM_STD_IDLE, 4.0f);
 				break;
 			case PEDMOVE_WALK:
-				animAssoc = CAnimManager::BlendAnimation(GetClump(), animGroupToUse, ANIM_WALK, 1.0f);
+				animAssoc = CAnimManager::BlendAnimation(GetClump(), animGroupToUse, ANIM_STD_WALK, 1.0f);
 				break;
 			case PEDMOVE_RUN:
 				if (m_nPedState == PED_FLEE_ENTITY) {
-					animAssoc = CAnimManager::BlendAnimation(GetClump(), animGroupToUse, ANIM_RUN, 3.0f);
+					animAssoc = CAnimManager::BlendAnimation(GetClump(), animGroupToUse, ANIM_STD_RUN, 3.0f);
 				} else {
-					animAssoc = CAnimManager::BlendAnimation(GetClump(), animGroupToUse, ANIM_RUN, 1.0f);
+					animAssoc = CAnimManager::BlendAnimation(GetClump(), animGroupToUse, ANIM_STD_RUN, 1.0f);
 				}
 				break;
 			case PEDMOVE_SPRINT:
-				animAssoc = CAnimManager::BlendAnimation(GetClump(), animGroupToUse, ANIM_SPRINT, 1.0f);
+				animAssoc = CAnimManager::BlendAnimation(GetClump(), animGroupToUse, ANIM_STD_RUNFAST, 1.0f);
 				break;
 			default:
 				break;
@@ -562,12 +562,12 @@ CPed::SetMoveAnim(void)
 
 		if (animAssoc) {
 			if (m_leader) {
-				CAnimBlendAssociation *walkAssoc = RpAnimBlendClumpGetAssociation(m_leader->GetClump(), ANIM_WALK);
+				CAnimBlendAssociation *walkAssoc = RpAnimBlendClumpGetAssociation(m_leader->GetClump(), ANIM_STD_WALK);
 				if (!walkAssoc)
-					walkAssoc = RpAnimBlendClumpGetAssociation(m_leader->GetClump(), ANIM_RUN);
+					walkAssoc = RpAnimBlendClumpGetAssociation(m_leader->GetClump(), ANIM_STD_RUN);
 
 				if (!walkAssoc)
-					walkAssoc = RpAnimBlendClumpGetAssociation(m_leader->GetClump(), ANIM_SPRINT);
+					walkAssoc = RpAnimBlendClumpGetAssociation(m_leader->GetClump(), ANIM_STD_RUNFAST);
 
 				if (walkAssoc) {
 					animAssoc->speed = walkAssoc->speed;
@@ -920,7 +920,7 @@ FinishFuckUCB(CAnimBlendAssociation *animAssoc, void *arg)
 {
 	CPed *ped = (CPed*)arg;
 
-	if (animAssoc->animId == ANIM_FUCKU && ped->GetWeapon()->m_eWeaponType == WEAPONTYPE_UNARMED)
+	if (animAssoc->animId == ANIM_STD_PARTIAL_FUCKU && ped->GetWeapon()->m_eWeaponType == WEAPONTYPE_UNARMED)
 			ped->RemoveWeaponModel(0);
 }
 
@@ -939,7 +939,7 @@ CPed::MoveHeadToLook(void)
 
 		if (!bShakeFist && GetWeapon()->m_eWeaponType == WEAPONTYPE_UNARMED) {
 
-			CAnimBlendAssociation *fuckUAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_FUCKU);
+			CAnimBlendAssociation *fuckUAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_PARTIAL_FUCKU);
 			if (fuckUAssoc) {
 
 				float animTime = fuckUAssoc->currentTime;
@@ -984,7 +984,7 @@ CPed::MoveHeadToLook(void)
 
 		bool notRocketLauncher = false;
 		bool notTwoHanded = false;
-		AnimationId animToPlay = NUM_ANIMS;
+		AnimationId animToPlay = ANIM_STD_NUM;
 
 		if (!GetWeapon()->IsType2Handed())
 			notTwoHanded = true;
@@ -1002,24 +1002,24 @@ CPed::MoveHeadToLook(void)
 #ifndef FIX_BUGS
 					if (m_pedStats->m_temper < 47)
 #endif
-						animToPlay = ANIM_FIGHT_PPUNCH;
+						animToPlay = ANIM_STD_PARTIAL_PUNCH;
 				} else {
-					animToPlay = ANIM_FUCKU;
+					animToPlay = ANIM_STD_PARTIAL_FUCKU;
 				}
 			} else if (m_pedStats->m_temper > 49 || m_pLookTarget->GetModelIndex() == MI_POLICE) {
-				animToPlay = ANIM_FUCKU;
+				animToPlay = ANIM_STD_PARTIAL_FUCKU;
 			}
 		} else if (notRocketLauncher && (CGeneral::GetRandomNumber() & 1)) {
-			animToPlay = ANIM_FUCKU;
+			animToPlay = ANIM_STD_PARTIAL_FUCKU;
 		}
 
-		if (animToPlay != NUM_ANIMS) {
+		if (animToPlay != ANIM_STD_NUM) {
 			CAnimBlendAssociation *newAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, animToPlay, 4.0f);
 
 			if (newAssoc) {
 				newAssoc->flags |= ASSOC_FADEOUTWHENDONE;
 				newAssoc->flags |= ASSOC_DELETEFADEDOUT;
-				if (newAssoc->animId == ANIM_FUCKU)
+				if (newAssoc->animId == ANIM_STD_PARTIAL_FUCKU)
 					newAssoc->SetDeleteCallback(FinishFuckUCB, this);
 			}
 		}
@@ -1365,8 +1365,8 @@ CPed::CalculateNewVelocity(void)
 		m_moved = CVector2D(-Sin(walkAngle), Cos(walkAngle)) * pedSpeed;
 	}
 
-	CAnimBlendAssociation *idleAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_IDLE_STANCE);
-	CAnimBlendAssociation *fightAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_FIGHT_IDLE);
+	CAnimBlendAssociation *idleAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_IDLE);
+	CAnimBlendAssociation *fightAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_FIGHT_IDLE);
 #ifdef VC_PED_PORTS
 	if ((!idleAssoc || idleAssoc->blendAmount < 0.5f) && !fightAssoc && !bIsDucking) {
 #else
@@ -1809,7 +1809,7 @@ CPed::ProcessControl(void)
 			++m_panicCounter;
 
 		if (m_fHealth <= 1.0f && m_nPedState <= PED_STATES_NO_AI && !bIsInTheAir && !bIsLanding)
-			SetDie(ANIM_KO_SHOT_FRONT1, 4.0f, 0.0f);
+			SetDie(ANIM_STD_KO_FRONT, 4.0f, 0.0f);
 
 		bCollidedWithMyVehicle = false;
 
@@ -1900,9 +1900,9 @@ CPed::ProcessControl(void)
 					} else {
 						if (m_nPedType != PEDTYPE_COP && neededTurn < DEGTORAD(15.0f) && m_nWaitState == WAITSTATE_FALSE) {
 							if ((m_nStoredMoveState == PEDMOVE_RUN || m_nStoredMoveState == PEDMOVE_SPRINT) && m_vecDamageNormal.z < 0.3f) {
-								CAnimBlendAssociation *runAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_RUN);
+								CAnimBlendAssociation *runAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_RUN);
 								if (!runAssoc)
-									runAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_SPRINT);
+									runAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_RUNFAST);
 
 								if (runAssoc && runAssoc->blendAmount > 0.9f && runAssoc->IsRunning()) {
 									SetWaitState(WAITSTATE_HITWALL, nil);
@@ -2189,7 +2189,7 @@ CPed::ProcessControl(void)
 								bIsStanding = false;
 								CVector2D collidingEntMoveDir = -collidingVeh->m_vecMoveSpeed;
 								int dir = GetLocalDirection(collidingEntMoveDir);
-								SetFall(1000, (AnimationId)(dir + ANIM_KO_SKID_FRONT), false);
+								SetFall(1000, (AnimationId)(dir + ANIM_STD_HIGHIMPACT_FRONT), false);
 
 								float damage;
 								if (collidingVeh->m_modelIndex == MI_TRAIN) {
@@ -2321,7 +2321,7 @@ CPed::ProcessControl(void)
 								bIsStanding = false;
 								CVector2D collidingEntMoveDir = -collidingVeh->m_vecMoveSpeed;
 								int dir = GetLocalDirection(collidingEntMoveDir);
-								SetFall(1000, (AnimationId)(dir + ANIM_KO_SKID_FRONT), false);
+								SetFall(1000, (AnimationId)(dir + ANIM_STD_HIGHIMPACT_FRONT), false);
 								CPed *driver = collidingVeh->pDriver;
 
 								float damage;
@@ -2479,7 +2479,7 @@ CPed::ProcessControl(void)
 						SetHeading(m_fRotationCur);
 
 						if (m_nPedState != PED_FALL && !bIsPedDieAnimPlaying) {
-							SetFall(1000, ANIM_KO_SKID_BACK, true);
+							SetFall(1000, ANIM_STD_HIGHIMPACT_BACK, true);
 						}
 						bIsInTheAir = false;
 					} else if (m_vecDamageNormal.z > 0.4f) {
@@ -2534,10 +2534,10 @@ CPed::ProcessControl(void)
 							m_fRotationCur = m_fRotationDest;
 							SetHeading(m_fRotationCur);
 						}
-						CAnimBlendAssociation *jumpAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_JUMP_GLIDE);
+						CAnimBlendAssociation *jumpAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_JUMP_GLIDE);
 
 						if (!jumpAssoc)
-							jumpAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_FALL_GLIDE);
+							jumpAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_FALL_GLIDE);
 
 						if (jumpAssoc) {
 							jumpAssoc->blendDelta = -3.0f;
@@ -2546,10 +2546,10 @@ CPed::ProcessControl(void)
 						if (m_nPedState == PED_JUMP)
 							m_nPedState = PED_IDLE;
 					} else {
-						CAnimBlendAssociation *jumpAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_JUMP_GLIDE);
+						CAnimBlendAssociation *jumpAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_JUMP_GLIDE);
 
 						if (!jumpAssoc)
-							jumpAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_FALL_GLIDE);
+							jumpAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_FALL_GLIDE);
 
 						if (jumpAssoc) {
 							jumpAssoc->blendDelta = -3.0f;
@@ -2675,7 +2675,7 @@ CPed::ProcessControl(void)
 				Wait();
 
 			if (m_nPedState != PED_IDLE) {
-				CAnimBlendAssociation *idleAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_IDLE_ARMED);
+				CAnimBlendAssociation *idleAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_IDLE_BIGGUN);
 				if(idleAssoc) {
 					idleAssoc->blendDelta = -8.0f;
 					idleAssoc->flags |= ASSOC_DELETEFADEDOUT;
@@ -2694,27 +2694,27 @@ CPed::ProcessControl(void)
 						int16 padWalkX = pad->GetPedWalkLeftRight();
 						int16 padWalkY = pad->GetPedWalkUpDown();
 						if (Abs(padWalkX) > 0.0f || Abs(padWalkY) > 0.0f) {
-							if (vehAnim == ANIM_CAR_OPEN_LHS || vehAnim == ANIM_CAR_OPEN_RHS || vehAnim == ANIM_COACH_OPEN_L || vehAnim == ANIM_COACH_OPEN_R ||
-								vehAnim == ANIM_VAN_OPEN_L || vehAnim == ANIM_VAN_OPEN) {
+							if (vehAnim == ANIM_STD_CAR_OPEN_DOOR_LHS || vehAnim == ANIM_STD_CAR_OPEN_DOOR_RHS || vehAnim == ANIM_STD_COACH_OPEN_LHS || vehAnim == ANIM_STD_COACH_OPEN_RHS ||
+								vehAnim == ANIM_STD_VAN_OPEN_DOOR_REAR_LHS || vehAnim == ANIM_STD_VAN_OPEN_DOOR_REAR_RHS) {
 
 								if (!m_pMyVehicle->pDriver) {
 									cancelJack = false;
 									bCancelEnteringCar = true;
 								} else
 									cancelJack = true;
-							} else if (vehAnim == ANIM_CAR_QJACK && m_pVehicleAnim->GetTimeLeft() > 0.75f) {
+							} else if (vehAnim == ANIM_STD_QUICKJACK && m_pVehicleAnim->GetTimeLeft() > 0.75f) {
 								cancelJack = true;
-							} else if (vehAnim == ANIM_CAR_PULLOUT_LHS || vehAnim == ANIM_CAR_PULLOUT_LOW_LHS || vehAnim == ANIM_CAR_PULLOUT_LOW_RHS || vehAnim == ANIM_CAR_PULLOUT_RHS) {
+							} else if (vehAnim == ANIM_STD_CAR_PULL_OUT_PED_LHS || vehAnim == ANIM_STD_CAR_PULL_OUT_PED_LO_LHS || vehAnim == ANIM_STD_CAR_PULL_OUT_PED_LO_RHS || vehAnim == ANIM_STD_CAR_PULL_OUT_PED_RHS) {
 								bCancelEnteringCar = true;
 								cancelJack = false;
 							}
 						}
-						if (cancelJack && vehAnim == ANIM_CAR_QJACK && m_pVehicleAnim->GetTimeLeft() > 0.75f && m_pVehicleAnim->GetTimeLeft() < 0.78f) {
+						if (cancelJack && vehAnim == ANIM_STD_QUICKJACK && m_pVehicleAnim->GetTimeLeft() > 0.75f && m_pVehicleAnim->GetTimeLeft() < 0.78f) {
 							cancelJack = false;
 							QuitEnteringCar();
 							RestorePreviousObjective();
 						}
-						if (cancelJack && (vehAnim == ANIM_CAR_PULLOUT_LHS || vehAnim == ANIM_CAR_PULLOUT_LOW_LHS || vehAnim == ANIM_CAR_PULLOUT_LOW_RHS || vehAnim == ANIM_CAR_PULLOUT_RHS)) {
+						if (cancelJack && (vehAnim == ANIM_STD_CAR_PULL_OUT_PED_LHS || vehAnim == ANIM_STD_CAR_PULL_OUT_PED_LO_LHS || vehAnim == ANIM_STD_CAR_PULL_OUT_PED_LO_RHS || vehAnim == ANIM_STD_CAR_PULL_OUT_PED_RHS)) {
 							cancelJack = false;
 							bCancelEnteringCar = true;
 						}
@@ -2874,25 +2874,25 @@ CPed::ProcessControl(void)
 					CAnimBlendAssociation *lbAssoc;
 					CAnimBlendAssociation *sitAssoc;
 					if (m_pMyVehicle->bLowVehicle) {
-						sitAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_CAR_LSIT);
+						sitAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CAR_SIT_LO);
 
 						if (!sitAssoc || sitAssoc->blendAmount < 1.0f) {
 							break;
 						}
 
-						lDriveAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_DRIVE_LOW_L);
+						lDriveAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CAR_DRIVE_LEFT_LO);
 						lbAssoc = nil;
-						rDriveAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_DRIVE_LOW_R);
+						rDriveAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CAR_DRIVE_RIGHT_LO);
 					} else {
-						sitAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_CAR_SIT);
+						sitAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CAR_SIT);
 
 						if (!sitAssoc || sitAssoc->blendAmount < 1.0f) {
 							break;
 						}
 
-						lDriveAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_DRIVE_L);
-						rDriveAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_DRIVE_R);
-						lbAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_CAR_LB);
+						lDriveAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CAR_DRIVE_LEFT);
+						rDriveAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CAR_DRIVE_RIGHT);
+						lbAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CAR_LOOKBEHIND);
 
 						if (lbAssoc &&
 							TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_1STPERSON
@@ -2901,10 +2901,10 @@ CPed::ProcessControl(void)
 						}
 					}
 
-					CAnimBlendAssociation *driveByAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_DRIVEBY_L);
+					CAnimBlendAssociation *driveByAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CAR_DRIVEBY_LEFT);
 
 					if (!driveByAssoc)
-						driveByAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_DRIVEBY_R);
+						driveByAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CAR_DRIVEBY_RIGHT);
 
 					if (m_pMyVehicle->bLowVehicle || m_pMyVehicle->m_fGasPedal >= 0.0f || driveByAssoc) {
 						if (steerAngle == 0.0f || driveByAssoc) {
@@ -2920,9 +2920,9 @@ CPed::ProcessControl(void)
 							if (rDriveAssoc)
 								rDriveAssoc->blendAmount = clamp(steerAngle * -100.0f / 61.0f, 0.0f, 1.0f);
 							else if (m_pMyVehicle->bLowVehicle)
-								CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_DRIVE_LOW_R);
+								CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_CAR_DRIVE_RIGHT_LO);
 							else
-								CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_DRIVE_R);
+								CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_CAR_DRIVE_RIGHT);
 
 						} else {
 							if (rDriveAssoc)
@@ -2931,9 +2931,9 @@ CPed::ProcessControl(void)
 							if (lDriveAssoc)
 								lDriveAssoc->blendAmount = clamp(steerAngle * 100.0f / 61.0f, 0.0f, 1.0f);
 							else if (m_pMyVehicle->bLowVehicle)
-								CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_DRIVE_LOW_L);
+								CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_CAR_DRIVE_LEFT_LO);
 							else
-								CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_DRIVE_L);
+								CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_CAR_DRIVE_LEFT);
 						}
 
 						if (lbAssoc)
@@ -2943,7 +2943,7 @@ CPed::ProcessControl(void)
 						if ((TheCamera.Cams[TheCamera.ActiveCam].Mode != CCam::MODE_1STPERSON
 							|| TheCamera.Cams[TheCamera.ActiveCam].DirectionWasLooking != LOOKING_LEFT)
 							&& (!lbAssoc || lbAssoc->blendAmount < 1.0f)) {
-							CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_CAR_LB, 4.0f);
+							CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_CAR_LOOKBEHIND, 4.0f);
 						}
 					}
 					break;
@@ -2953,12 +2953,12 @@ CPed::ProcessControl(void)
 					break;
 				case PED_HANDS_UP:
 					if (m_pedStats->m_temper <= 50) {
-						if (!RpAnimBlendClumpGetAssociation(GetClump(), ANIM_HANDSCOWER)) {
-							CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_HANDSCOWER);
+						if (!RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_HANDSCOWER)) {
+							CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_HANDSCOWER);
 							Say(SOUND_PED_HANDS_COWER);
 						}
-					} else if (!RpAnimBlendClumpGetAssociation(GetClump(), ANIM_HANDSUP)) {
-						CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_HANDSUP);
+					} else if (!RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_HANDSUP)) {
+						CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_HANDSUP);
 						Say(SOUND_PED_HANDS_UP);
 					}
 					break;
@@ -3150,7 +3150,7 @@ CPed::ProcessEntityCollision(CEntity *collidingEnt, CColPoint *collidingPoints)
 							upperSpeedLimit *= 2.0f;
 							lowerSpeedLimit *= 1.5f;
 						}
-						CAnimBlendAssociation *fallAnim = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_FALL_FALL);
+						CAnimBlendAssociation *fallAnim = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_FALL);
 						if (!bWasStanding && speed > upperSpeedLimit && (/*!bPushedAlongByCar ||*/ m_vecMoveSpeed.z < lowerSpeedLimit)
 							&& m_pCollidingEntity != collidingEnt) {
 
@@ -3174,7 +3174,7 @@ CPed::ProcessEntityCollision(CEntity *collidingEnt, CColPoint *collidingPoints)
 						}
 #else
 						float speedSqr = 0.0f;
-						CAnimBlendAssociation *fallAnim = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_FALL_FALL);
+						CAnimBlendAssociation *fallAnim = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_FALL);
 						if (!bWasStanding && (m_vecMoveSpeed.z < -0.25f || (speedSqr = m_vecMoveSpeed.MagnitudeSqr()) > sq(0.5f))) {
 							if (speedSqr == 0.0f)
 								speedSqr = sq(m_vecMoveSpeed.z);
@@ -3326,10 +3326,10 @@ CPed::PlayFootSteps(void)
 	
 	if ( IsPlayer() )
 	{	
-		runStopAsoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_RUN_STOP);
+		runStopAsoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_RUNSTOP2);
 		
 		if ( runStopAsoc == NULL )
-			runStopAsoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_RUN_STOP_R);
+			runStopAsoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_RUNSTOP2);
 	}
 	
 	if ( runStopAsoc != NULL && runStopAsoc->blendAmount > 0.1f )
@@ -4158,7 +4158,7 @@ CPed::PedSetOutCarCB(CAnimBlendAssociation *animAssoc, void *arg)
 #ifdef VC_PED_PORTS
 	else if (ped->m_objective == OBJECTIVE_LEAVE_CAR_AND_DIE) {
 		ped->m_fHealth = 0.0f;
-		ped->SetDie(ANIM_FLOOR_HIT, 4.0f, 0.5f);
+		ped->SetDie(ANIM_STD_HIT_FLOOR, 4.0f, 0.5f);
 	}
 #endif
 
@@ -4286,7 +4286,7 @@ CPed::PedSetOutCarCB(CAnimBlendAssociation *animAssoc, void *arg)
 
 	ped->bOnBoat = false;
 	if (ped->bBusJacked) {
-		ped->SetFall(1500, ANIM_KO_SKID_BACK, false);
+		ped->SetFall(1500, ANIM_STD_HIGHIMPACT_BACK, false);
 		ped->bBusJacked = false;
 	}
 	ped->m_nStoredMoveState = PEDMOVE_NONE;
@@ -4310,7 +4310,7 @@ CPed::PedSetDraggedOutCarCB(CAnimBlendAssociation *dragAssoc, void *arg)
 	CVehicle *vehicle; 
 	CPed *ped = (CPed*)arg;
 
-	quickJackedAssoc = RpAnimBlendClumpGetAssociation(ped->GetClump(), ANIM_CAR_QJACKED);
+	quickJackedAssoc = RpAnimBlendClumpGetAssociation(ped->GetClump(), ANIM_STD_QUICKJACKED);
 	if (ped->m_nPedState != PED_ARRESTED) {
 		ped->m_nLastPedState = PED_NONE;
 		if (dragAssoc)
@@ -4343,7 +4343,7 @@ CPed::PedSetDraggedOutCarCB(CAnimBlendAssociation *dragAssoc, void *arg)
 	if (ped->m_objective == OBJECTIVE_LEAVE_CAR_AND_DIE) {
 		dragAssoc->SetDeleteCallback(PedSetDraggedOutCarPositionCB, ped);
 		ped->m_fHealth = 0.0f;
-		ped->SetDie(ANIM_FLOOR_HIT, 1000.0f, 0.5f);
+		ped->SetDie(ANIM_STD_HIT_FLOOR, 1000.0f, 0.5f);
 		return;
 	}
 #endif
@@ -4353,7 +4353,7 @@ CPed::PedSetDraggedOutCarCB(CAnimBlendAssociation *dragAssoc, void *arg)
 	} else {
 		dragAssoc->SetDeleteCallback(PedSetDraggedOutCarPositionCB, ped);
 		if (ped->CanSetPedState())
-			CAnimManager::BlendAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_GETUP1, 1000.0f);
+			CAnimManager::BlendAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_STD_GET_UP, 1000.0f);
 	}
 
 	ped->ReplaceWeaponWhenExitingVehicle();
@@ -4588,14 +4588,14 @@ CPed::PedSetInCarCB(CAnimBlendAssociation *animAssoc, void *arg)
 
 	if (veh->pDriver == ped) {
 		if (veh->bLowVehicle) {
-			ped->m_pVehicleAnim = CAnimManager::BlendAnimation(ped->GetClump(),	ASSOCGRP_STD, ANIM_CAR_LSIT, 100.0f);
+			ped->m_pVehicleAnim = CAnimManager::BlendAnimation(ped->GetClump(),	ASSOCGRP_STD, ANIM_STD_CAR_SIT_LO, 100.0f);
 		} else {
-			ped->m_pVehicleAnim = CAnimManager::BlendAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_CAR_SIT, 100.0f);
+			ped->m_pVehicleAnim = CAnimManager::BlendAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_STD_CAR_SIT, 100.0f);
 		}
 	} else if (veh->bLowVehicle) {
-		ped->m_pVehicleAnim = CAnimManager::BlendAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_CAR_SITPLO, 100.0f);
+		ped->m_pVehicleAnim = CAnimManager::BlendAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_STD_CAR_SIT_P_LO, 100.0f);
 	} else {
-		ped->m_pVehicleAnim = CAnimManager::BlendAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_CAR_SITP, 100.0f);
+		ped->m_pVehicleAnim = CAnimManager::BlendAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_STD_CAR_SIT_P, 100.0f);
 	}
 	
 	ped->StopNonPartialAnims();
@@ -4839,7 +4839,7 @@ CPed::PreRender(void)
 
 			if (Abs(speed.x) <= 0.05f && Abs(speed.y) <= 0.05f) {
 				if (!OnGround() && m_nPedState != PED_ATTACK && m_nPedState != PED_FIGHT) {
-					if (!IsPedHeadAbovePos(0.3f) || RpAnimBlendClumpGetAssociation(GetClump(), ANIM_IDLE_TIRED)) {
+					if (!IsPedHeadAbovePos(0.3f) || RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_IDLE_TIRED)) {
 						doSplashUp = false;
 					}
 				} else
@@ -4973,8 +4973,8 @@ CPed::Idle(void)
 		}
 	}
 
-	CAnimBlendAssociation *armedIdleAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_IDLE_ARMED);
-	CAnimBlendAssociation *unarmedIdleAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_IDLE_STANCE);
+	CAnimBlendAssociation *armedIdleAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_IDLE_BIGGUN);
+	CAnimBlendAssociation *unarmedIdleAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_IDLE);
 	int waitTime;
 
 	if (m_nMoveState == PEDMOVE_STILL) {
@@ -4989,7 +4989,7 @@ CPed::Idle(void)
 				m_moved = CVector2D(0.0f, 0.0f);
 				return;
 			}
-			CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_IDLE_ARMED, 3.0f);
+			CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_IDLE_BIGGUN, 3.0f);
 			waitTime = CGeneral::GetRandomNumberInRange(4000, 7500);
 		} else {
 			armedIdleAssoc->blendDelta = -2.0f;
@@ -5113,7 +5113,7 @@ CPed::SetInTheAir(void)
 		return;
 
 	bIsInTheAir = true;
-	CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_FALL_GLIDE, 4.0f);
+	CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_FALL_GLIDE, 4.0f);
 
 	if (m_nPedState == PED_ATTACK) {
 		ClearAttack();
@@ -5144,9 +5144,9 @@ CPed::InTheAir(void)
 					)
 					SetLanding();
 			} else {
-				if (!RpAnimBlendClumpGetAssociation(GetClump(), ANIM_FALL_FALL)) {
+				if (!RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_FALL)) {
 					if (m_vecMoveSpeed.z < -0.1f)
-						CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_FALL_FALL, 4.0f);
+						CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_FALL, 4.0f);
 				}
 			}
 		}
@@ -5159,19 +5159,19 @@ CPed::SetLanding(void)
 	if (DyingOrDead())
 		return;
 
-	CAnimBlendAssociation *fallAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_FALL_FALL);
+	CAnimBlendAssociation *fallAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_FALL);
 	CAnimBlendAssociation *landAssoc;
 
 	RpAnimBlendClumpSetBlendDeltas(GetClump(), ASSOC_PARTIAL, -1000.0f);
 	if (fallAssoc) {
-		landAssoc = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_FALL_COLLAPSE);
+		landAssoc = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_FALL_COLLAPSE);
 		DMAudio.PlayOneShot(m_audioEntityId, SOUND_FALL_COLLAPSE, 1.0f);
 
 		if (IsPlayer())
 			Say(SOUND_PED_LAND);
 
 	} else {
-		landAssoc = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_FALL_LAND);
+		landAssoc = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_FALL_LAND);
 		DMAudio.PlayOneShot(m_audioEntityId, SOUND_FALL_LAND, 1.0f);
 	}
 
@@ -5222,25 +5222,25 @@ CPed::SetGetUp(void)
 		bGetUpAnimStarted = true;
 		m_pCollidingEntity = nil;
 		bKnockedUpIntoAir = false;
-		CAnimBlendAssociation *animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_SPRINT);
+		CAnimBlendAssociation *animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_RUNFAST);
 		if (animAssoc) {
-			if (RpAnimBlendClumpGetAssociation(GetClump(), ANIM_RUN)) {
-				CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_RUN, 8.0f);
+			if (RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_RUN)) {
+				CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_STD_RUN, 8.0f);
 			} else {
-				CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_IDLE_STANCE, 8.0f);
+				CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_STD_IDLE, 8.0f);
 			}
 			animAssoc->flags |= ASSOC_DELETEFADEDOUT;
 		}
 
 		if (RpAnimBlendClumpGetFirstAssociation(GetClump(), ASSOC_FRONTAL))
-			animAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_GETUP_FRONT, 1000.0f);
+			animAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_GET_UP_FRONT, 1000.0f);
 		else
-			animAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_GETUP1, 1000.0f);
+			animAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_GET_UP, 1000.0f);
 
 		animAssoc->SetFinishCallback(PedGetupCB,this);
 	} else {
 		m_fHealth = 0.0f;
-		SetDie(NUM_ANIMS, 4.0f, 0.0f);
+		SetDie(ANIM_STD_NUM, 4.0f, 0.0f);
 	}
 }
 
@@ -6087,7 +6087,7 @@ CPed::SetEvasiveStep(CEntity *reason, uint8 animType)
 	if (neededTurn <= DEGTORAD(90.0f) || veh->GetModelIndex() == MI_RCBANDIT || vehPressedHorn || animType != 0) {
 		SetLookFlag(veh, true);
 		if ((CGeneral::GetRandomNumber() & 1) && veh->GetModelIndex() != MI_RCBANDIT && animType == 0) {
-			stepAnim = ANIM_IDLE_TAXI;
+			stepAnim = ANIM_STD_HAILTAXI;
 		} else {
 
 			float vehDirection = CGeneral::GetRadianAngleBetweenPoints(
@@ -6110,11 +6110,11 @@ CPed::SetEvasiveStep(CEntity *reason, uint8 animType)
 			else
 				angleToFace = vehDirection + HALFPI;
 
-			stepAnim = NUM_ANIMS;
+			stepAnim = ANIM_STD_NUM;
 			if (animType == 0 || animType == 1)
-				stepAnim = ANIM_EV_STEP;
+				stepAnim = ANIM_STD_EVADE_STEP;
 			else if (animType == 2)
-				stepAnim = ANIM_HANDSCOWER;
+				stepAnim = ANIM_STD_HANDSCOWER;
 		}
 		if (!RpAnimBlendClumpGetAssociation(GetClump(), stepAnim)) {
 			CAnimBlendAssociation *stepAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, stepAnim, 8.0f);
@@ -6216,11 +6216,11 @@ CPed::SetEvasiveDive(CPhysical *reason, uint8 onlyRandomJump)
 		ClearLookFlag();
 		ClearAimFlag();
 		SetLookFlag(reason, true);
-		animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_HANDSUP);
+		animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_HANDSUP);
 		if (animAssoc)
 			return;
 
-		animAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_HANDSUP, 8.0f);
+		animAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_HANDSUP, 8.0f);
 		animAssoc->flags &= ~ASSOC_DELETEFADEDOUT;
 		animAssoc->SetFinishCallback(PedEvadeCB, this);
 		SetStoredState();
@@ -6231,7 +6231,7 @@ CPed::SetEvasiveDive(CPhysical *reason, uint8 onlyRandomJump)
 		ClearAimFlag();
 		SetStoredState();
 		SetPedState(PED_DIVE_AWAY);
-		animAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_EV_DIVE, 8.0f);
+		animAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_EVADE_DIVE, 8.0f);
 		animAssoc->SetFinishCallback(PedEvadeCB, this);
 	}
 
@@ -6262,7 +6262,7 @@ CPed::PedEvadeCB(CAnimBlendAssociation* animAssoc, void* arg)
 		if (ped->m_nPedState == PED_DIVE_AWAY || ped->m_nPedState == PED_STEP_AWAY)
 			ped->RestorePreviousState();
 	
-	} else if (animAssoc->animId == ANIM_EV_DIVE) {
+	} else if (animAssoc->animId == ANIM_STD_EVADE_DIVE) {
 		ped->bUpdateAnimHeading = true;
 		ped->ClearLookFlag();
 		if (ped->m_nPedState == PED_DIVE_AWAY)
@@ -6320,7 +6320,7 @@ CPed::SetDie(AnimationId animId, float delta, float speed)
 	}
 
 	SetPedState(PED_DIE);
-	if (animId == NUM_ANIMS) {
+	if (animId == ANIM_STD_NUM) {
 		bIsPedDieAnimPlaying = false;
 	} else {
 		CAnimBlendAssociation *dieAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, animId, delta);
@@ -6429,7 +6429,7 @@ CPed::Chat(void)
 	}
 	if (bIsTalking) {
 		if (CGeneral::GetRandomNumber() < 512) {
-			CAnimBlendAssociation *chatAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_IDLE_CHAT);
+			CAnimBlendAssociation *chatAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CHAT);
 			if (chatAssoc) {
 				chatAssoc->blendDelta = -4.0f;
 				chatAssoc->flags |= ASSOC_DELETEFADEDOUT;
@@ -6441,10 +6441,10 @@ CPed::Chat(void)
 	} else {
 
 		if (CGeneral::GetRandomNumber() < 20 && !RpAnimBlendClumpGetFirstAssociation(GetClump(), ASSOC_IDLE)) {
-			CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_XPRESS_SCRATCH, 4.0f);
+			CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_XPRESS_SCRATCH, 4.0f);
 		}
 		if (!bIsTalking && !RpAnimBlendClumpGetFirstAssociation(GetClump(), ASSOC_IDLE)) {
-			CAnimBlendAssociation *chatAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_IDLE_CHAT, 4.0f);
+			CAnimBlendAssociation *chatAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_CHAT, 4.0f);
 			float chatTime = CGeneral::GetRandomNumberInRange(0.0f, 3.0f);
 			chatAssoc->SetCurrentTime(chatTime);
 
@@ -6461,7 +6461,7 @@ CPed::Chat(void)
 void
 CPed::ClearChat(void)
 {
-	CAnimBlendAssociation *animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_IDLE_CHAT);
+	CAnimBlendAssociation *animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CHAT);
 	if (animAssoc) {
 		animAssoc->blendDelta = -8.0f;
 		animAssoc->flags |= ASSOC_DELETEFADEDOUT;
@@ -6477,10 +6477,10 @@ ReportPhonePickUpCB(CAnimBlendAssociation* assoc, void* arg)
 {
 	CPed* ped = (CPed*)arg;
 	ped->m_nMoveState = PEDMOVE_STILL;
-	CAnimManager::BlendAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_IDLE_STANCE, 8.0f);
+	CAnimManager::BlendAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_STD_IDLE, 8.0f);
 
 	if (assoc->blendAmount > 0.5f && ped) {
-		CAnimManager::BlendAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_PHONE_TALK, 8.0f);
+		CAnimManager::BlendAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_STD_PHONE_TALK, 8.0f);
 	}
 }
 
@@ -6524,7 +6524,7 @@ CPed::FacePhone(void)
 		ClearLookFlag();
 		SetIdle();
 		m_phoneTalkTimer = CTimer::GetTimeInMilliseconds() + 10000;
-		CAnimBlendAssociation* assoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_PHONE_IN, 4.0f);
+		CAnimBlendAssociation* assoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_PHONE_IN, 4.0f);
 		assoc->SetFinishCallback(ReportPhonePickUpCB, this);
 		return true;
 	}
@@ -6579,9 +6579,9 @@ CPed::MakePhonecall(void)
 		return false;
 
 #ifdef PEDS_REPORT_CRIMES_ON_PHONE
-	CAnimBlendAssociation* talkAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_PHONE_TALK);
+	CAnimBlendAssociation* talkAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_PHONE_TALK);
 	if (talkAssoc && talkAssoc->blendAmount > 0.5f) {
-		CAnimBlendAssociation* endAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_PHONE_OUT, 8.0f);
+		CAnimBlendAssociation* endAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_PHONE_OUT, 8.0f);
 		endAssoc->flags &= ~ASSOC_DELETEFADEDOUT;
 		endAssoc->SetFinishCallback(ReportPhonePutDownCB, this);
 	}
@@ -6911,18 +6911,18 @@ CPed::SetPedPositionInCar(void)
 
 	if (bChangedSeat) {
 		bool notYet = false;
-		if (RpAnimBlendClumpGetAssociation(GetClump(), ANIM_CAR_GETIN_LHS)
-			|| RpAnimBlendClumpGetAssociation(GetClump(), ANIM_CAR_GETIN_LOW_LHS)
-			|| RpAnimBlendClumpGetAssociation(GetClump(), ANIM_CAR_CLOSEDOOR_LHS)
-			|| RpAnimBlendClumpGetAssociation(GetClump(), ANIM_CAR_CLOSEDOOR_LOW_LHS)
-			|| RpAnimBlendClumpGetAssociation(GetClump(), ANIM_CAR_SHUFFLE_RHS)
-			|| RpAnimBlendClumpGetAssociation(GetClump(), ANIM_CAR_LSHUFFLE_RHS)
-			|| RpAnimBlendClumpGetAssociation(GetClump(), ANIM_VAN_CLOSE_L)
-			|| RpAnimBlendClumpGetAssociation(GetClump(), ANIM_VAN_CLOSE)
-			|| RpAnimBlendClumpGetAssociation(GetClump(), ANIM_VAN_GETIN_L)
-			|| RpAnimBlendClumpGetAssociation(GetClump(), ANIM_VAN_GETIN)
-			|| RpAnimBlendClumpGetAssociation(GetClump(), ANIM_COACH_IN_L)
-			|| RpAnimBlendClumpGetAssociation(GetClump(), ANIM_COACH_IN_R)) {
+		if (RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CAR_GET_IN_LHS)
+			|| RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CAR_GET_IN_LO_LHS)
+			|| RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CAR_CLOSE_DOOR_LHS)
+			|| RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CAR_CLOSE_DOOR_LO_LHS)
+			|| RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CAR_SHUFFLE_RHS)
+			|| RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CAR_SHUFFLE_LO_RHS)
+			|| RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_VAN_CLOSE_DOOR_REAR_LHS)
+			|| RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_VAN_CLOSE_DOOR_REAR_RHS)
+			|| RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_VAN_GET_IN_REAR_LHS)
+			|| RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_VAN_GET_IN_REAR_RHS)
+			|| RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_COACH_GET_IN_LHS)
+			|| RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_COACH_GET_IN_RHS)) {
 			notYet = true;
 		}
 		if (notYet) {
@@ -7175,7 +7175,7 @@ CPed::LookForInterestingNodes(void)
 void
 CPed::SetWaitState(eWaitState state, void *time)
 {
-	AnimationId waitAnim = NUM_ANIMS;
+	AnimationId waitAnim = ANIM_STD_NUM;
 	CAnimBlendAssociation *animAssoc;
 
 	if (!IsPedInControl())
@@ -7191,10 +7191,10 @@ CPed::SetWaitState(eWaitState state, void *time)
 			break;
 		case WAITSTATE_CROSS_ROAD:
 			m_nWaitTimer = CTimer::GetTimeInMilliseconds() + 1000;
-			CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_IDLE_HBHB, 4.0f);
+			CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_IDLE_HBHB, 4.0f);
 			break;
 		case WAITSTATE_CROSS_ROAD_LOOK:
-			CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_ROAD_CROSS, 8.0f);
+			CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_ROADCROSS, 8.0f);
 
 			if (time)
 				m_nWaitTimer = CTimer::GetTimeInMilliseconds() + *(int*)time;
@@ -7210,7 +7210,7 @@ CPed::SetWaitState(eWaitState state, void *time)
 		case WAITSTATE_DOUBLEBACK:
 			m_headingRate = 0.0f;
 			m_nWaitTimer = CTimer::GetTimeInMilliseconds() + 3500;
-			animAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_IDLE_HBHB, 4.0f);
+			animAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_IDLE_HBHB, 4.0f);
 #ifdef FIX_BUGS
 			animAssoc->SetFinishCallback(RestoreHeadingRateCB, this);
 #endif
@@ -7218,7 +7218,7 @@ CPed::SetWaitState(eWaitState state, void *time)
 		case WAITSTATE_HITWALL:
 			m_headingRate = 2.0f;
 			m_nWaitTimer = CTimer::GetTimeInMilliseconds() + 5000;
-			animAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_HIT_WALL, 16.0f);
+			animAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_HIT_WALL, 16.0f);
 			animAssoc->flags |= ASSOC_DELETEFADEDOUT;
 			animAssoc->flags |= ASSOC_FADEOUTWHENDONE;
 			animAssoc->SetDeleteCallback(FinishedWaitCB, this);
@@ -7232,14 +7232,14 @@ CPed::SetWaitState(eWaitState state, void *time)
 		case WAITSTATE_TURN180:
 			m_headingRate = 0.0f;
 			m_nWaitTimer = CTimer::GetTimeInMilliseconds() + 5000;
-			animAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_TURN_180, 4.0f);
+			animAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_TURN180, 4.0f);
 			animAssoc->SetFinishCallback(FinishedWaitCB, this);
 			animAssoc->SetDeleteCallback(RestoreHeadingRateCB, this);
 			break;
 		case WAITSTATE_SURPRISE:
 			m_headingRate = 0.0f;
 			m_nWaitTimer = CTimer::GetTimeInMilliseconds() + 2000;
-			animAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_HIT_WALL, 4.0f);
+			animAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_HIT_WALL, 4.0f);
 			animAssoc->SetFinishCallback(FinishedWaitCB, this);
 			break;
 		case WAITSTATE_STUCK:
@@ -7247,7 +7247,7 @@ CPed::SetWaitState(eWaitState state, void *time)
 			SetMoveAnim();
 			m_headingRate = 0.0f;
 			m_nWaitTimer = CTimer::GetTimeInMilliseconds() + 5000;
-			animAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_IDLE_TIRED, 4.0f);
+			animAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_IDLE_TIRED, 4.0f);
 #ifdef FIX_BUGS
 			animAssoc->SetFinishCallback(RestoreHeadingRateCB, this);
 #endif
@@ -7263,20 +7263,20 @@ CPed::SetWaitState(eWaitState state, void *time)
 			SetMoveAnim();
 			m_headingRate = 0.0f;
 			m_nWaitTimer = CTimer::GetTimeInMilliseconds() + 5000;
-			animAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_IDLE_HBHB, 4.0f);
+			animAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_IDLE_HBHB, 4.0f);
 #ifdef FIX_BUGS
 			animAssoc->SetFinishCallback(RestoreHeadingRateCB, this);
 #endif
 
 			break;
 		case WAITSTATE_PLAYANIM_COWER:
-			waitAnim = ANIM_HANDSCOWER;
+			waitAnim = ANIM_STD_HANDSCOWER;
 		case WAITSTATE_PLAYANIM_HANDSUP:
-			if (waitAnim == NUM_ANIMS)
-				waitAnim = ANIM_HANDSUP;
+			if (waitAnim == ANIM_STD_NUM)
+				waitAnim = ANIM_STD_HANDSUP;
 		case WAITSTATE_PLAYANIM_HANDSCOWER:
-			if (waitAnim == NUM_ANIMS)
-				waitAnim = ANIM_HANDSCOWER;
+			if (waitAnim == ANIM_STD_NUM)
+				waitAnim = ANIM_STD_HANDSCOWER;
 			m_headingRate = 0.0f;
 			if (time)
 				m_nWaitTimer = CTimer::GetTimeInMilliseconds() + *(int*)time;
@@ -7287,13 +7287,13 @@ CPed::SetWaitState(eWaitState state, void *time)
 			animAssoc->SetDeleteCallback(FinishedWaitCB, this);
 			break;
 		case WAITSTATE_PLAYANIM_DUCK:
-			waitAnim = ANIM_DUCK_DOWN;
+			waitAnim = ANIM_STD_DUCK_DOWN;
 		case WAITSTATE_PLAYANIM_TAXI:
-			if (waitAnim == NUM_ANIMS)
-				waitAnim = ANIM_IDLE_TAXI;
+			if (waitAnim == ANIM_STD_NUM)
+				waitAnim = ANIM_STD_HAILTAXI;
 		case WAITSTATE_PLAYANIM_CHAT:
-			if (waitAnim == NUM_ANIMS)
-				waitAnim = ANIM_IDLE_CHAT;
+			if (waitAnim == ANIM_STD_NUM)
+				waitAnim = ANIM_STD_CHAT;
 			if (time)
 				m_nWaitTimer = CTimer::GetTimeInMilliseconds() + *(int*)time;
 			else
@@ -7309,7 +7309,7 @@ CPed::SetWaitState(eWaitState state, void *time)
 			SetMoveAnim();
 			m_headingRate = 0.0f;
 			m_nWaitTimer = CTimer::GetTimeInMilliseconds() + 2500;
-			animAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_IDLE_TIRED, 4.0f);
+			animAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_IDLE_TIRED, 4.0f);
 #ifdef FIX_BUGS
 			animAssoc->SetFinishCallback(RestoreHeadingRateCB, this);
 #endif
@@ -7325,7 +7325,7 @@ CPed::SetWaitState(eWaitState state, void *time)
 void
 CPed::Wait(void)
 {
-	AnimationId mustHaveAnim = NUM_ANIMS;
+	AnimationId mustHaveAnim = ANIM_STD_NUM;
 	CAnimBlendAssociation *animAssoc;
 	CPed *pedWeLook;
 
@@ -7353,7 +7353,7 @@ CPed::Wait(void)
 				else
 					SetWaitState(WAITSTATE_CROSS_ROAD_LOOK, nil);
 
-				animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_IDLE_HBHB);
+				animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_IDLE_HBHB);
 				if (animAssoc) {
 					animAssoc->blendDelta = -8.0f;
 					animAssoc->flags |= ASSOC_DELETEFADEDOUT;
@@ -7364,7 +7364,7 @@ CPed::Wait(void)
 		case WAITSTATE_CROSS_ROAD_LOOK:
 			if (CTimer::GetTimeInMilliseconds() > m_nWaitTimer) {
 				m_nWaitState = WAITSTATE_FALSE;
-				animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_ROAD_CROSS);
+				animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_ROADCROSS);
 				if (animAssoc) {
 					animAssoc->blendDelta = -8.0f;
 					animAssoc->flags |= ASSOC_DELETEFADEDOUT;
@@ -7377,7 +7377,7 @@ CPed::Wait(void)
 				uint32 timeLeft = m_nWaitTimer - CTimer::GetTimeInMilliseconds();
 				if (timeLeft < 2500 && timeLeft > 2000) {
 					m_nWaitTimer -= 500;
-					CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_XPRESS_SCRATCH, 4.0f);
+					CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_XPRESS_SCRATCH, 4.0f);
 				}
 			} else {
 				m_nWaitState = WAITSTATE_FALSE;
@@ -7411,8 +7411,8 @@ CPed::Wait(void)
 
 		case WAITSTATE_SURPRISE:
 			if (CTimer::GetTimeInMilliseconds() > m_nWaitTimer) {
-				if (RpAnimBlendClumpGetAssociation(GetClump(), ANIM_HIT_WALL)) {
-					animAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_XPRESS_SCRATCH, 4.0f);
+				if (RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_HIT_WALL)) {
+					animAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_XPRESS_SCRATCH, 4.0f);
 					animAssoc->SetFinishCallback(FinishedWaitCB, this);
 					m_nWaitTimer = CTimer::GetTimeInMilliseconds() + 5000;
 				} else {
@@ -7425,14 +7425,14 @@ CPed::Wait(void)
 			if (CTimer::GetTimeInMilliseconds() <= m_nWaitTimer)
 				break;
 
-			animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_IDLE_TIRED);
+			animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_IDLE_TIRED);
 
 			if (!animAssoc)
-				animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_TURN_180);
+				animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_TURN180);
 			if (!animAssoc)
-				animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_XPRESS_SCRATCH);
+				animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_XPRESS_SCRATCH);
 			if (!animAssoc)
-				animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_ROAD_CROSS);
+				animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_ROADCROSS);
 
 			if (animAssoc) {
 				if (animAssoc->IsPartial()) {
@@ -7440,10 +7440,10 @@ CPed::Wait(void)
 					animAssoc->flags |= ASSOC_DELETEFADEDOUT;
 				} else {
 					animAssoc->flags |= ASSOC_DELETEFADEDOUT;
-					CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_IDLE_STANCE, 4.0f);
+					CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_STD_IDLE, 4.0f);
 				}
 
-				if (animAssoc->animId == ANIM_TURN_180) {
+				if (animAssoc->animId == ANIM_STD_TURN180) {
 					m_fRotationCur = CGeneral::LimitRadianAngle(PI + m_fRotationCur);
 					m_nWaitState = WAITSTATE_FALSE;
 					SetMoveState(PEDMOVE_WALK);
@@ -7457,16 +7457,16 @@ CPed::Wait(void)
 
 			switch (CGeneral::GetRandomNumber() & 3) {
 				case 0:
-					animToPlay = ANIM_ROAD_CROSS;
+					animToPlay = ANIM_STD_ROADCROSS;
 					break;
 				case 1:
-					animToPlay = ANIM_IDLE_TIRED;
+					animToPlay = ANIM_STD_IDLE_TIRED;
 					break;
 				case 2:
-					animToPlay = ANIM_XPRESS_SCRATCH;
+					animToPlay = ANIM_STD_XPRESS_SCRATCH;
 					break;
 				case 3:
-					animToPlay = ANIM_TURN_180;
+					animToPlay = ANIM_STD_TURN180;
 					break;
 				default:
 					break;
@@ -7474,7 +7474,7 @@ CPed::Wait(void)
 
 			animAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, animToPlay, 4.0f);
 
-			if (animToPlay == ANIM_TURN_180)
+			if (animToPlay == ANIM_STD_TURN180)
 				animAssoc->SetFinishCallback(FinishedWaitCB, this);
 
 			m_nWaitTimer = CTimer::GetTimeInMilliseconds() + CGeneral::GetRandomNumberInRange(1500, 5000);
@@ -7483,7 +7483,7 @@ CPed::Wait(void)
 		case WAITSTATE_LOOK_ABOUT:
 			if (CTimer::GetTimeInMilliseconds() > m_nWaitTimer) {
 				m_nWaitState = WAITSTATE_FALSE;
-				animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_IDLE_HBHB);
+				animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_IDLE_HBHB);
 				if (animAssoc) {
 					animAssoc->blendDelta = -8.0f;
 					animAssoc->flags |= ASSOC_DELETEFADEDOUT;
@@ -7492,11 +7492,11 @@ CPed::Wait(void)
 			break;
 
 		case WAITSTATE_PLAYANIM_HANDSUP:
-			mustHaveAnim = ANIM_HANDSUP;
+			mustHaveAnim = ANIM_STD_HANDSUP;
 			
 		case WAITSTATE_PLAYANIM_HANDSCOWER:
-			if (mustHaveAnim == NUM_ANIMS)
-				mustHaveAnim = ANIM_HANDSCOWER;
+			if (mustHaveAnim == ANIM_STD_NUM)
+				mustHaveAnim = ANIM_STD_HANDSCOWER;
 
 			animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), mustHaveAnim);
 			pedWeLook = (CPed*) m_pLookTarget;
@@ -7564,19 +7564,19 @@ CPed::Wait(void)
 			}
 			break;
 		case WAITSTATE_PLAYANIM_COWER:
-			mustHaveAnim = ANIM_HANDSCOWER;
+			mustHaveAnim = ANIM_STD_HANDSCOWER;
 
 		case WAITSTATE_PLAYANIM_DUCK:
-			if (mustHaveAnim == NUM_ANIMS)
-				mustHaveAnim = ANIM_DUCK_DOWN;
+			if (mustHaveAnim == ANIM_STD_NUM)
+				mustHaveAnim = ANIM_STD_DUCK_DOWN;
 
 		case WAITSTATE_PLAYANIM_TAXI:
-			if (mustHaveAnim == NUM_ANIMS)
-				mustHaveAnim = ANIM_IDLE_TAXI;
+			if (mustHaveAnim == ANIM_STD_NUM)
+				mustHaveAnim = ANIM_STD_HAILTAXI;
 
 		case WAITSTATE_PLAYANIM_CHAT:
-			if (mustHaveAnim == NUM_ANIMS)
-				mustHaveAnim = ANIM_IDLE_CHAT;
+			if (mustHaveAnim == ANIM_STD_NUM)
+				mustHaveAnim = ANIM_STD_CHAT;
 
 			if (CTimer::GetTimeInMilliseconds() > m_nWaitTimer) {
 				animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), mustHaveAnim);
@@ -7602,11 +7602,11 @@ CPed::Wait(void)
 			break;
 
 		case WAITSTATE_FINISH_FLEE:
-			animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_IDLE_TIRED);
+			animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_IDLE_TIRED);
 			if (animAssoc) {
 				if (CTimer::GetTimeInMilliseconds() > m_nWaitTimer) {
 					animAssoc->flags |= ASSOC_DELETEFADEDOUT;
-					CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_IDLE_STANCE, 4.0f);
+					CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_STD_IDLE, 4.0f);
 					int timer = 2000;
 					m_nWaitState = WAITSTATE_FALSE;
 					SetWaitState(WAITSTATE_CROSS_ROAD_LOOK, &timer);
@@ -7686,7 +7686,7 @@ CPed::SetSolicit(uint32 time)
 			m_chatTimer = CTimer::GetTimeInMilliseconds() + time;
 
 			if(!m_carInObjective->bIsVan && !m_carInObjective->bIsBus)
-				m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_CAR_HOOKERTALK, 4.0f);
+				m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_CAR_HOOKERTALK, 4.0f);
 
 			SetPedState(PED_SOLICIT);
 		}
@@ -7713,7 +7713,7 @@ CPed::Solicit(void)
 
 		if ((GetPosition() - doorPos).MagnitudeSqr() <= 1.0f)
 			return;
-		CAnimBlendAssociation *talkAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_CAR_HOOKERTALK);
+		CAnimBlendAssociation *talkAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CAR_HOOKERTALK);
 		if (talkAssoc) {
 			talkAssoc->blendDelta = -1000.0f;
 			talkAssoc->flags |= ASSOC_DELETEFADEDOUT;
@@ -7959,12 +7959,12 @@ CPed::SetJump(void)
 {
 	if (!bInVehicle &&
 #if defined VC_PED_PORTS || defined FIX_BUGS
-		m_nPedState != PED_JUMP && !RpAnimBlendClumpGetAssociation(GetClump(), ANIM_JUMP_LAUNCH) &&
+		m_nPedState != PED_JUMP && !RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_JUMP_LAUNCH) &&
 #endif
 		(m_nSurfaceTouched != SURFACE_STEEP_CLIFF || DotProduct(GetForward(), m_vecDamageNormal) >= 0.0f)) {
 		SetStoredState();
 		SetPedState(PED_JUMP);
-		CAnimBlendAssociation *jumpAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_JUMP_LAUNCH, 8.0f);
+		CAnimBlendAssociation *jumpAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_JUMP_LAUNCH, 8.0f);
 		jumpAssoc->SetFinishCallback(FinishLaunchCB, this);
 		m_fRotationDest = m_fRotationCur;
 	}
@@ -7993,7 +7993,7 @@ CPed::FinishLaunchCB(CAnimBlendAssociation *animAssoc, void *arg)
 		animAssoc->flags |= ASSOC_DELETEFADEDOUT;
 
 		// ANIM_HIT_WALL in VC (which makes more sense)
-		CAnimBlendAssociation *handsCoverAssoc = CAnimManager::BlendAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_HANDSCOWER, 8.0f);
+		CAnimBlendAssociation *handsCoverAssoc = CAnimManager::BlendAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_STD_HANDSCOWER, 8.0f);
 		handsCoverAssoc->flags &= ~ASSOC_FADEOUTWHENDONE;
 		handsCoverAssoc->SetFinishCallback(FinishHitHeadCB, ped);
 		ped->bIsLanding = true;
@@ -8001,12 +8001,12 @@ CPed::FinishLaunchCB(CAnimBlendAssociation *animAssoc, void *arg)
 	}
 
 	float velocityFromAnim = 0.1f;
-	CAnimBlendAssociation *sprintAssoc = RpAnimBlendClumpGetAssociation(ped->GetClump(), ANIM_SPRINT);
+	CAnimBlendAssociation *sprintAssoc = RpAnimBlendClumpGetAssociation(ped->GetClump(), ANIM_STD_RUNFAST);
 
 	if (sprintAssoc) {
 		velocityFromAnim = 0.05f * sprintAssoc->blendAmount + 0.17f;
 	} else {
-		CAnimBlendAssociation *runAssoc = RpAnimBlendClumpGetAssociation(ped->GetClump(), ANIM_RUN);
+		CAnimBlendAssociation *runAssoc = RpAnimBlendClumpGetAssociation(ped->GetClump(), ANIM_STD_RUN);
 		if (runAssoc) {
 			velocityFromAnim = 0.07f * runAssoc->blendAmount + 0.1f;
 		}
@@ -8050,7 +8050,7 @@ CPed::FinishLaunchCB(CAnimBlendAssociation *animAssoc, void *arg)
 	ped->bIsStanding = false;
 	ped->bIsInTheAir = true;
 	animAssoc->blendDelta = -1000.0f;
-	CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_JUMP_GLIDE);
+	CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_STD_JUMP_GLIDE);
 
 	if (ped->bDoBloodyFootprints) {
 		CVector bloodPos(0.0f, 0.0f, 0.0f);
@@ -8318,7 +8318,7 @@ CPed::WarpPedIntoCar(CVehicle *car)
 #else
 	if (car->IsBoat()) {
 #ifndef FIX_BUGS
-		m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_DRIVE_BOAT, 100.0f);
+		m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_BOAT_DRIVE, 100.0f);
 #else
 		m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, car->GetDriverAnim(), 100.0f);
 #endif
@@ -8329,9 +8329,9 @@ CPed::WarpPedIntoCar(CVehicle *car)
 		RemoveWeaponWhenEnteringVehicle();
 
 		if (car->bLowVehicle)
-			m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_CAR_LSIT, 100.0f);
+			m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_CAR_SIT_LO, 100.0f);
 		else
-			m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_CAR_SIT, 100.0f);
+			m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_CAR_SIT, 100.0f);
 	}
 #endif
 
diff --git a/src/peds/PedAI.cpp b/src/peds/PedAI.cpp
index 089c8d9d..56c9429a 100644
--- a/src/peds/PedAI.cpp
+++ b/src/peds/PedAI.cpp
@@ -1121,7 +1121,7 @@ CPed::ProcessObjective(void)
 				if (m_attackTimer < CTimer::GetTimeInMilliseconds()
 					&& distWithTargetSc < wepRange && m_pedInObjective->m_nPedState != PED_GETUP && m_pedInObjective->m_nPedState != PED_DRAG_FROM_CAR) {
 					if (bIsDucking) {
-						CAnimBlendAssociation *duckAnim = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_DUCK_DOWN);
+						CAnimBlendAssociation *duckAnim = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_DUCK_DOWN);
 						if (duckAnim) {
 							duckAnim->blendDelta = -2.0f;
 							break;
@@ -1202,14 +1202,14 @@ CPed::ProcessObjective(void)
 						// This is weird...
 						if (bNotAllowedToDuck && bKindaStayInSamePlace) {
 							if (!bIsDucking) {
-								CAnimBlendAssociation* duckAnim = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_DUCK_DOWN);
+								CAnimBlendAssociation* duckAnim = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_DUCK_DOWN);
 								if (!duckAnim || duckAnim->blendDelta < 0.0f) {
-									CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_DUCK_DOWN, 4.0f);
+									CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_DUCK_DOWN, 4.0f);
 									bIsDucking = true;
 								}
 								break;
 							} else {
-								CAnimBlendAssociation* duckAnim = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_DUCK_DOWN);
+								CAnimBlendAssociation* duckAnim = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_DUCK_DOWN);
 								if (!duckAnim || duckAnim->blendDelta < 0.0f) {
 									bIsDucking = false;
 								} else {
@@ -1701,9 +1701,9 @@ CPed::ProcessObjective(void)
 				}
 				break;
 			case OBJECTIVE_HAIL_TAXI:
-				if (!RpAnimBlendClumpGetAssociation(GetClump(), ANIM_IDLE_TAXI) && CTimer::GetTimeInMilliseconds() > m_nWaitTimer) {
+				if (!RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_HAILTAXI) && CTimer::GetTimeInMilliseconds() > m_nWaitTimer) {
 					Say(SOUND_PED_TAXI_WAIT);
-					CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_IDLE_TAXI, 4.0f);
+					CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_HAILTAXI, 4.0f);
 					m_nWaitTimer = CTimer::GetTimeInMilliseconds() + 2000;
 				}
 				break;
@@ -1813,7 +1813,7 @@ CPed::ProcessObjective(void)
 					float distWithTargetScSqr = distWithTarget.MagnitudeSqr();
 					if (distWithTargetScSqr <= sq(10.0f)) {
 						if (distWithTargetScSqr <= sq(1.4f)) {
-							CAnimBlendAssociation *reloadAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_AK_RELOAD);
+							CAnimBlendAssociation *reloadAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_AK_RELOAD);
 							m_fRotationDest = CGeneral::GetRadianAngleBetweenPoints(
 								m_pedInObjective->GetPosition().x, m_pedInObjective->GetPosition().y,
 								GetPosition().x, GetPosition().y);
@@ -1821,7 +1821,7 @@ CPed::ProcessObjective(void)
 							if (reloadAssoc || !m_pedInObjective->IsPedShootable()) {
 								if (reloadAssoc &&
 									(!reloadAssoc->IsRunning() || reloadAssoc->currentTime / reloadAssoc->hierarchy->totalLength > 0.8f)) {
-									CAnimBlendAssociation *punchAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_FIGHT_PPUNCH, 8.0f);
+									CAnimBlendAssociation *punchAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_PARTIAL_PUNCH, 8.0f);
 									punchAssoc->flags |= ASSOC_DELETEFADEDOUT;
 									punchAssoc->flags |= ASSOC_FADEOUTWHENDONE;
 									CVector2D offset(distWithTarget.x, distWithTarget.y);
@@ -1850,13 +1850,13 @@ CPed::ProcessObjective(void)
 								if (weaponType != WEAPONTYPE_UNARMED && weaponType != WEAPONTYPE_BASEBALLBAT)
 									SetCurrentWeapon(WEAPONTYPE_UNARMED);
 
-								CAnimBlendAssociation *newReloadAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_AK_RELOAD, 8.0f);
+								CAnimBlendAssociation *newReloadAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_AK_RELOAD, 8.0f);
 								newReloadAssoc->flags |= ASSOC_DELETEFADEDOUT;
 								newReloadAssoc->flags |= ASSOC_FADEOUTWHENDONE;
 							}
 						} else {
 							SetSeek(m_pedInObjective, 1.0f);
-							CAnimBlendAssociation *walkAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_WALK);
+							CAnimBlendAssociation *walkAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_WALK);
 
 							if (walkAssoc)
 								walkAssoc->speed = 1.3f;
@@ -2256,26 +2256,26 @@ CPed::PedAnimAlignCB(CAnimBlendAssociation *animAssoc, void *arg)
 		}
 		if (enterDoor != DOOR_FRONT_LEFT && enterDoor != DOOR_REAR_LEFT) {
 			if (itsVan) {
-				enterAnim = ANIM_VAN_GETIN;
+				enterAnim = ANIM_STD_VAN_GET_IN_REAR_RHS;
 			} else if (itsBus) {
-				enterAnim = ANIM_COACH_IN_R;
+				enterAnim = ANIM_STD_COACH_GET_IN_RHS;
 #ifdef FIX_BUGS
 			} else if (itsLow) {
-				enterAnim = ANIM_CAR_GETIN_LOW_RHS;
+				enterAnim = ANIM_STD_CAR_GET_IN_LO_RHS;
 #endif
 			} else {
-				enterAnim = ANIM_CAR_GETIN_RHS;
+				enterAnim = ANIM_STD_CAR_GET_IN_RHS;
 			}
 		} else if (itsVan) {
-			enterAnim = ANIM_VAN_GETIN_L;
+			enterAnim = ANIM_STD_VAN_GET_IN_REAR_LHS;
 		} else if (itsBus) {
-			enterAnim = ANIM_COACH_IN_L;
+			enterAnim = ANIM_STD_COACH_GET_IN_LHS;
 #ifdef FIX_BUGS
 		} else if (itsLow) {
-			enterAnim = ANIM_CAR_GETIN_LOW_LHS;
+			enterAnim = ANIM_STD_CAR_GET_IN_LO_LHS;
 #endif
 		} else {
-			enterAnim = ANIM_CAR_GETIN_LHS;
+			enterAnim = ANIM_STD_CAR_GET_IN_LHS;
 		}
 		ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, enterAnim);
 		ped->m_pVehicleAnim->SetFinishCallback(PedAnimGetInCB, ped);
@@ -2285,16 +2285,16 @@ CPed::PedAnimAlignCB(CAnimBlendAssociation *animAssoc, void *arg)
 		veh->AutoPilot.m_nCruiseSpeed = 0;
 		if (enterDoor != DOOR_FRONT_LEFT && enterDoor != DOOR_REAR_LEFT) {
 			if (itsVan) {
-				ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_VAN_OPEN);
+				ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_STD_VAN_OPEN_DOOR_REAR_RHS);
 			} else if (itsBus) {
-				ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_COACH_OPEN_R);
+				ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_STD_COACH_OPEN_RHS);
 			} else {
-				ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_CAR_OPEN_RHS);
+				ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_STD_CAR_OPEN_DOOR_RHS);
 			}
 		} else if (itsVan) {
-			ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_VAN_OPEN_L);
+			ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_STD_VAN_OPEN_DOOR_REAR_LHS);
 		} else if (itsBus) {
-			ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_COACH_OPEN_L);
+			ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_STD_COACH_OPEN_LHS);
 		} else {
 
 			if (ped->m_objective == OBJECTIVE_ENTER_CAR_AS_DRIVER && veh->pDriver) {
@@ -2303,7 +2303,7 @@ CPed::PedAnimAlignCB(CAnimBlendAssociation *animAssoc, void *arg)
 					&& veh->pDriver->CharCreatedBy != MISSION_CHAR
 					&& veh->pDriver->m_nPedState == PED_DRIVING) {
 
-					ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_CAR_QJACK);
+					ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_STD_QUICKJACK);
 					ped->m_pVehicleAnim->SetFinishCallback(PedAnimGetInCB, ped);
 					veh->pDriver->SetBeingDraggedFromCar(veh, ped->m_vehDoor, true);
 
@@ -2312,15 +2312,15 @@ CPed::PedAnimAlignCB(CAnimBlendAssociation *animAssoc, void *arg)
 					return;
 				}
 			}
-			ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_CAR_OPEN_LHS);
+			ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_STD_CAR_OPEN_DOOR_LHS);
 		}
 		ped->m_pVehicleAnim->SetFinishCallback(PedAnimDoorOpenCB, ped);
 
 	} else {
 		if (enterDoor != DOOR_FRONT_LEFT && enterDoor != DOOR_REAR_LEFT)
-			ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_CAR_DOORLOCKED_RHS);
+			ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_STD_CARDOOR_LOCKED_RHS);
 		else
-			ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_CAR_DOORLOCKED_LHS);
+			ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_STD_CARDOOR_LOCKED_LHS);
 
 		ped->bCancelEnteringCar = true;
 		ped->m_pVehicleAnim->SetFinishCallback(PedAnimDoorOpenCB, ped);
@@ -2393,13 +2393,13 @@ CPed::PedAnimDoorOpenCB(CAnimBlendAssociation* animAssoc, void* arg)
 	if (veh->m_vecMoveSpeed.Magnitude() > 0.2f) {
 		ped->QuitEnteringCar();
 		if (ped->m_vehDoor != CAR_DOOR_LF && ped->m_vehDoor != CAR_DOOR_LR)
-			ped->SetFall(1000, ANIM_KO_SPIN_R, false);
+			ped->SetFall(1000, ANIM_STD_HIGHIMPACT_LEFT, false);
 		else
-			ped->SetFall(1000, ANIM_KO_SPIN_L, false);
+			ped->SetFall(1000, ANIM_STD_HIGHIMPACT_RIGHT, false);
 		
 		return;
 	}
-	veh->ProcessOpenDoor(ped->m_vehDoor, ANIM_CAR_OPEN_LHS, 1.0f);
+	veh->ProcessOpenDoor(ped->m_vehDoor, ANIM_STD_CAR_OPEN_DOOR_LHS, 1.0f);
 
 	if (ped->m_vehDoor == CAR_DOOR_LF || ped->m_vehDoor == CAR_DOOR_RF)
 		isVan = false;
@@ -2409,22 +2409,22 @@ CPed::PedAnimDoorOpenCB(CAnimBlendAssociation* animAssoc, void* arg)
 		if (ped->m_vehDoor != CAR_DOOR_LF && ped->m_vehDoor != CAR_DOOR_LR) {
 
 			if (isVan) {
-				animToPlay = ANIM_VAN_GETIN;
+				animToPlay = ANIM_STD_VAN_GET_IN_REAR_RHS;
 			} else if (isBus) {
-				animToPlay = ANIM_COACH_IN_R;
+				animToPlay = ANIM_STD_COACH_GET_IN_RHS;
 			} else if (isLow) {
-				animToPlay = ANIM_CAR_GETIN_LOW_RHS;
+				animToPlay = ANIM_STD_CAR_GET_IN_LO_RHS;
 			} else {
-				animToPlay = ANIM_CAR_GETIN_RHS;
+				animToPlay = ANIM_STD_CAR_GET_IN_RHS;
 			}
 		} else if (isVan) {
-			animToPlay = ANIM_VAN_GETIN_L;
+			animToPlay = ANIM_STD_VAN_GET_IN_REAR_LHS;
 		} else if (isBus) {
-			animToPlay = ANIM_COACH_IN_L;
+			animToPlay = ANIM_STD_COACH_GET_IN_LHS;
 		} else if (isLow) {
-			animToPlay = ANIM_CAR_GETIN_LOW_LHS;
+			animToPlay = ANIM_STD_CAR_GET_IN_LO_LHS;
 		} else {
-			animToPlay = ANIM_CAR_GETIN_LHS;
+			animToPlay = ANIM_STD_CAR_GET_IN_LHS;
 		}
 		ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, animToPlay);
 		ped->m_pVehicleAnim->SetFinishCallback(PedAnimGetInCB, ped);
@@ -2451,9 +2451,9 @@ CPed::PedAnimDoorOpenCB(CAnimBlendAssociation* animAssoc, void* arg)
 					pedToDragOut = nil;
 				} else {
 					if (isLow)
-						ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_CAR_PULLOUT_LOW_RHS);
+						ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_STD_CAR_PULL_OUT_PED_LO_RHS);
 					else
-						ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_CAR_PULLOUT_RHS);
+						ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_STD_CAR_PULL_OUT_PED_RHS);
 
 					ped->m_pVehicleAnim->SetFinishCallback(PedAnimPullPedOutCB, ped);
 				}
@@ -2468,9 +2468,9 @@ CPed::PedAnimDoorOpenCB(CAnimBlendAssociation* animAssoc, void* arg)
 			} else {
 				// BUG: Probably we will sit on top of the passenger if his m_ped_flagF4 is true.
 				if (isLow)
-					ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_CAR_GETIN_LOW_LHS);
+					ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_STD_CAR_GET_IN_LO_LHS);
 				else
-					ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_CAR_GETIN_LHS);
+					ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_STD_CAR_GET_IN_LHS);
 
 				ped->m_pVehicleAnim->SetFinishCallback(PedAnimGetInCB, ped);
 			}
@@ -2483,17 +2483,17 @@ CPed::PedAnimDoorOpenCB(CAnimBlendAssociation* animAssoc, void* arg)
 					pedToDragOut = nil;
 				} else {
 					if (isLow)
-						ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_CAR_PULLOUT_LOW_LHS);
+						ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_STD_CAR_PULL_OUT_PED_LO_LHS);
 					else
-						ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_CAR_PULLOUT_LHS);
+						ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_STD_CAR_PULL_OUT_PED_LHS);
 					
 					ped->m_pVehicleAnim->SetFinishCallback(PedAnimPullPedOutCB, ped);
 				}
 			} else {
 				if (isLow)
-					ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_CAR_GETIN_LOW_LHS);
+					ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_STD_CAR_GET_IN_LO_LHS);
 				else
-					ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_CAR_GETIN_LHS);
+					ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_STD_CAR_GET_IN_LHS);
 
 				ped->m_pVehicleAnim->SetFinishCallback(PedAnimGetInCB, ped);
 			}
@@ -2577,13 +2577,13 @@ CPed::PedAnimPullPedOutCB(CAnimBlendAssociation* animAssoc, void* arg)
 			AnimationId animToPlay;
 			if (ped->m_vehDoor != CAR_DOOR_LF && ped->m_vehDoor != CAR_DOOR_LR) {
 				if (isLow)
-					animToPlay = ANIM_CAR_GETIN_LOW_RHS;
+					animToPlay = ANIM_STD_CAR_GET_IN_LO_RHS;
 				else
-					animToPlay = ANIM_CAR_GETIN_RHS;
+					animToPlay = ANIM_STD_CAR_GET_IN_RHS;
 			} else if (isLow) {
-				animToPlay = ANIM_CAR_GETIN_LOW_LHS;
+				animToPlay = ANIM_STD_CAR_GET_IN_LO_LHS;
 			} else {
-				animToPlay = ANIM_CAR_GETIN_LHS;
+				animToPlay = ANIM_STD_CAR_GET_IN_LHS;
 			}
 			ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, animToPlay);
 			ped->m_pVehicleAnim->SetFinishCallback(PedAnimGetInCB, ped);
@@ -2717,18 +2717,18 @@ CPed::PedAnimGetInCB(CAnimBlendAssociation *animAssoc, void *arg)
 		AnimationId animToPlay;
 		if (enterDoor != DOOR_FRONT_LEFT && enterDoor != DOOR_REAR_LEFT) {
 			if (isVan) {
-				animToPlay = ANIM_VAN_CLOSE;
+				animToPlay = ANIM_STD_VAN_CLOSE_DOOR_REAR_RHS;
 			} else if (isLow) {
-				animToPlay = ANIM_CAR_CLOSEDOOR_LOW_RHS;
+				animToPlay = ANIM_STD_CAR_CLOSE_DOOR_LO_RHS;
 			} else {
-				animToPlay = ANIM_CAR_CLOSEDOOR_RHS;
+				animToPlay = ANIM_STD_CAR_CLOSE_DOOR_RHS;
 			}
 		} else if (isVan) {
-			animToPlay = ANIM_VAN_CLOSE_L;
+			animToPlay = ANIM_STD_VAN_CLOSE_DOOR_REAR_LHS;
 		} else if (isLow) {
-			animToPlay = ANIM_CAR_CLOSEDOOR_LOW_LHS;
+			animToPlay = ANIM_STD_CAR_CLOSE_DOOR_LO_LHS;
 		} else {
-			animToPlay = ANIM_CAR_CLOSEDOOR_LHS;
+			animToPlay = ANIM_STD_CAR_CLOSE_DOOR_LHS;
 		}
 		ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, animToPlay);
 		ped->m_pVehicleAnim->SetFinishCallback(PedAnimDoorCloseCB, ped);
@@ -2749,7 +2749,7 @@ CPed::PedAnimDoorCloseCB(CAnimBlendAssociation *animAssoc, void *arg)
 		bool isLow = !!veh->bLowVehicle;
 
 		if (!veh->bIsBus)
-			veh->ProcessOpenDoor(ped->m_vehDoor, ANIM_CAR_CLOSEDOOR_LHS, 1.0f);
+			veh->ProcessOpenDoor(ped->m_vehDoor, ANIM_STD_CAR_CLOSE_DOOR_LHS, 1.0f);
 
 		eDoors door;
 		switch (ped->m_vehDoor) {
@@ -2796,9 +2796,9 @@ CPed::PedAnimDoorCloseCB(CAnimBlendAssociation *animAssoc, void *arg)
 				animAssoc->blendDelta = -1000.0f;
 
 			if (isLow)
-				ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_CAR_LSHUFFLE_RHS);
+				ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_STD_CAR_SHUFFLE_LO_RHS);
 			else
-				ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_CAR_SHUFFLE_RHS);
+				ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_STD_CAR_SHUFFLE_RHS);
 
 			ped->m_pVehicleAnim->SetFinishCallback(PedSetInCarCB, ped);
 		}
@@ -2902,7 +2902,7 @@ CPed::PedAnimStepOutCarCB(CAnimBlendAssociation* animAssoc, void* arg)
 	veh->m_vecMoveSpeed += CVector(0.001f, 0.001f, 0.001f);
 	veh->m_vecTurnSpeed += CVector(0.001f, 0.001f, 0.001f);
 	if (!veh->bIsBus)
-		veh->ProcessOpenDoor(ped->m_vehDoor, ANIM_CAR_GETOUT_LHS, 1.0f);
+		veh->ProcessOpenDoor(ped->m_vehDoor, ANIM_STD_GETOUT_LHS, 1.0f);
 
 	/* 
 	// Duplicate and only in PC for some reason
@@ -2991,16 +2991,16 @@ CPed::PedAnimStepOutCarCB(CAnimBlendAssociation* animAssoc, void* arg)
 	} else {
 		switch (door) {
 			case DOOR_FRONT_LEFT:
-				ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_CAR_CLOSE_LHS);
+				ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_STD_CAR_CLOSE_LHS);
 				break;
 			case DOOR_FRONT_RIGHT:
-				ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_CAR_CLOSE_RHS);
+				ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_STD_CAR_CLOSE_RHS);
 				break;
 			case DOOR_REAR_LEFT:
-				ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_CAR_CLOSE_LHS);
+				ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_STD_CAR_CLOSE_LHS);
 				break;
 			case DOOR_REAR_RIGHT:
-				ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_CAR_CLOSE_RHS);
+				ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_STD_CAR_CLOSE_RHS);
 				break;
 			default:
 				break;
@@ -3026,19 +3026,19 @@ CPed::LineUpPedWithCar(PedLineUpPhase phase)
 		return;
 
 	if (!bChangedSeat && phase != LINE_UP_TO_CAR_2) {
-		if (RpAnimBlendClumpGetAssociation(GetClump(), ANIM_CAR_SIT)) {
+		if (RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CAR_SIT)) {
 			SetPedPositionInCar();
 			return;
 		}
-		if (RpAnimBlendClumpGetAssociation(GetClump(), ANIM_CAR_LSIT)) {
+		if (RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CAR_SIT_LO)) {
 			SetPedPositionInCar();
 			return;
 		}
-		if (RpAnimBlendClumpGetAssociation(GetClump(), ANIM_CAR_SITP)) {
+		if (RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CAR_SIT_P)) {
 			SetPedPositionInCar();
 			return;
 		}
-		if (RpAnimBlendClumpGetAssociation(GetClump(), ANIM_CAR_SITPLO)) {
+		if (RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CAR_SIT_P_LO)) {
 			SetPedPositionInCar();
 			return;
 		}
@@ -3093,22 +3093,22 @@ CPed::LineUpPedWithCar(PedLineUpPhase phase)
 		vehAnim = m_pVehicleAnim->animId;
 
 		switch (vehAnim) {
-			case ANIM_CAR_JACKED_RHS:
-			case ANIM_CAR_LJACKED_RHS:
-			case ANIM_CAR_JACKED_LHS:
-			case ANIM_CAR_LJACKED_LHS:
-			case ANIM_VAN_GETIN_L:
-			case ANIM_VAN_GETIN:
+			case ANIM_STD_JACKEDCAR_RHS:
+			case ANIM_STD_JACKEDCAR_LO_RHS:
+			case ANIM_STD_JACKEDCAR_LHS:
+			case ANIM_STD_JACKEDCAR_LO_LHS:
+			case ANIM_STD_VAN_GET_IN_REAR_LHS:
+			case ANIM_STD_VAN_GET_IN_REAR_RHS:
 #ifdef VC_PED_PORTS
 				multExtractedFromAnim = true;
 				zBlend = Max(m_pVehicleAnim->currentTime / m_pVehicleAnim->hierarchy->totalLength - 0.3f, 0.0f) / (1.0f - 0.3f);
 				// fall through
 #endif
-			case ANIM_CAR_QJACKED:
-			case ANIM_CAR_GETOUT_LHS:
-			case ANIM_CAR_GETOUT_LOW_LHS:
-			case ANIM_CAR_GETOUT_RHS:
-			case ANIM_CAR_GETOUT_LOW_RHS:
+			case ANIM_STD_QUICKJACKED:
+			case ANIM_STD_GETOUT_LHS:
+			case ANIM_STD_GETOUT_LO_LHS:
+			case ANIM_STD_GETOUT_RHS:
+			case ANIM_STD_GETOUT_LO_RHS:
 #ifdef VC_PED_PORTS
 				if (!multExtractedFromAnim) {
 					multExtractedFromAnim = true;
@@ -3116,14 +3116,14 @@ CPed::LineUpPedWithCar(PedLineUpPhase phase)
 				}
 				// fall through
 #endif
-			case ANIM_CAR_CRAWLOUT_RHS:
-			case ANIM_CAR_CRAWLOUT_RHS2:
-			case ANIM_VAN_GETOUT_L:
-			case ANIM_VAN_GETOUT:
+			case ANIM_STD_CRAWLOUT_LHS:
+			case ANIM_STD_CRAWLOUT_RHS:
+			case ANIM_STD_VAN_GET_OUT_REAR_LHS:
+			case ANIM_STD_VAN_GET_OUT_REAR_RHS:
 				seatPosMult = m_pVehicleAnim->currentTime / m_pVehicleAnim->hierarchy->totalLength;
 				break;
-			case ANIM_CAR_GETIN_RHS:
-			case ANIM_CAR_GETIN_LHS:
+			case ANIM_STD_CAR_GET_IN_RHS:
+			case ANIM_STD_CAR_GET_IN_LHS:
 #ifdef VC_PED_PORTS
 				if (veh && veh->IsCar() && veh->bIsBus) {
 					multExtractedFromAnimBus = true;
@@ -3131,27 +3131,27 @@ CPed::LineUpPedWithCar(PedLineUpPhase phase)
 				}
 				// fall through
 #endif
-			case ANIM_CAR_QJACK:
-			case ANIM_CAR_GETIN_LOW_LHS:
-			case ANIM_CAR_GETIN_LOW_RHS:
-			case ANIM_DRIVE_BOAT:
+			case ANIM_STD_QUICKJACK:
+			case ANIM_STD_CAR_GET_IN_LO_LHS:
+			case ANIM_STD_CAR_GET_IN_LO_RHS:
+			case ANIM_STD_BOAT_DRIVE:
 				seatPosMult = m_pVehicleAnim->GetTimeLeft() / m_pVehicleAnim->hierarchy->totalLength;
 				break;
-			case ANIM_CAR_CLOSEDOOR_LHS:
-			case ANIM_CAR_CLOSEDOOR_LOW_LHS:
-			case ANIM_CAR_CLOSEDOOR_RHS:
-			case ANIM_CAR_CLOSEDOOR_LOW_RHS:
-			case ANIM_CAR_SHUFFLE_RHS:
-			case ANIM_CAR_LSHUFFLE_RHS:
+			case ANIM_STD_CAR_CLOSE_DOOR_LHS:
+			case ANIM_STD_CAR_CLOSE_DOOR_LO_LHS:
+			case ANIM_STD_CAR_CLOSE_DOOR_RHS:
+			case ANIM_STD_CAR_CLOSE_DOOR_LO_RHS:
+			case ANIM_STD_CAR_SHUFFLE_RHS:
+			case ANIM_STD_CAR_SHUFFLE_LO_RHS:
 				seatPosMult = 0.0f;
 				break;
-			case ANIM_CAR_CLOSE_LHS:
-			case ANIM_CAR_CLOSE_RHS:
-			case ANIM_COACH_OPEN_L:
-			case ANIM_COACH_OPEN_R:
-			case ANIM_COACH_IN_L:
-			case ANIM_COACH_IN_R:
-			case ANIM_COACH_OUT_L:
+			case ANIM_STD_CAR_CLOSE_LHS:
+			case ANIM_STD_CAR_CLOSE_RHS:
+			case ANIM_STD_COACH_OPEN_LHS:
+			case ANIM_STD_COACH_OPEN_RHS:
+			case ANIM_STD_COACH_GET_IN_LHS:
+			case ANIM_STD_COACH_GET_IN_RHS:
+			case ANIM_STD_COACH_GET_OUT_LHS:
 				seatPosMult = 1.0f;
 				break;
 			default:
@@ -3203,10 +3203,10 @@ CPed::LineUpPedWithCar(PedLineUpPhase phase)
 		} else {
 #endif
 			currentZ = GetPosition().z;
-			if (m_pVehicleAnim && vehAnim != ANIM_VAN_GETIN_L && vehAnim != ANIM_VAN_CLOSE_L && vehAnim != ANIM_VAN_CLOSE && vehAnim != ANIM_VAN_GETIN) {
+			if (m_pVehicleAnim && vehAnim != ANIM_STD_VAN_GET_IN_REAR_LHS && vehAnim != ANIM_STD_VAN_CLOSE_DOOR_REAR_LHS && vehAnim != ANIM_STD_VAN_CLOSE_DOOR_REAR_RHS && vehAnim != ANIM_STD_VAN_GET_IN_REAR_RHS) {
 				neededPos.z = autoZPos.z;
 				m_vecMoveSpeed = CVector(0.0f, 0.0f, 0.0f);
-			} else if (neededPos.z < currentZ && m_pVehicleAnim && vehAnim != ANIM_VAN_CLOSE_L && vehAnim != ANIM_VAN_CLOSE) {
+			} else if (neededPos.z < currentZ && m_pVehicleAnim && vehAnim != ANIM_STD_VAN_CLOSE_DOOR_REAR_LHS && vehAnim != ANIM_STD_VAN_CLOSE_DOOR_REAR_RHS) {
 				adjustedTimeStep = Max(m_pVehicleAnim->timeStep, 0.1f);
 
 				// Smoothly change ped position
@@ -3227,8 +3227,8 @@ CPed::LineUpPedWithCar(PedLineUpPhase phase)
 				} else {
 #endif
 					if (m_pVehicleAnim &&
-						(vehAnim == ANIM_CAR_GETIN_RHS || vehAnim == ANIM_CAR_GETIN_LOW_RHS || vehAnim == ANIM_CAR_GETIN_LHS || vehAnim == ANIM_CAR_GETIN_LOW_LHS
-							|| vehAnim == ANIM_CAR_QJACK || vehAnim == ANIM_VAN_GETIN_L || vehAnim == ANIM_VAN_GETIN)) {
+						(vehAnim == ANIM_STD_CAR_GET_IN_RHS || vehAnim == ANIM_STD_CAR_GET_IN_LO_RHS || vehAnim == ANIM_STD_CAR_GET_IN_LHS || vehAnim == ANIM_STD_CAR_GET_IN_LO_LHS
+							|| vehAnim == ANIM_STD_QUICKJACK || vehAnim == ANIM_STD_VAN_GET_IN_REAR_LHS || vehAnim == ANIM_STD_VAN_GET_IN_REAR_RHS)) {
 						adjustedTimeStep = Max(m_pVehicleAnim->timeStep, 0.1f);
 
 						// Smoothly change ped position
@@ -3358,9 +3358,9 @@ CPed::SetCarJack_AllClear(CVehicle *car, uint32 doorNode, uint32 doorFlag)
 	bUsesCollision = false;
 
 	if (m_vehDoor == CAR_DOOR_LF || m_vehDoor == CAR_DOOR_LR)
-		m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, zDiff > 4.4f ? ANIM_CAR_ALIGNHI_LHS : ANIM_CAR_ALIGN_LHS, 4.0f);
+		m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, zDiff > 4.4f ? ANIM_STD_CAR_ALIGNHI_DOOR_LHS : ANIM_STD_CAR_ALIGN_DOOR_LHS, 4.0f);
 	else
-		m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, zDiff > 4.4f ? ANIM_CAR_ALIGNHI_RHS : ANIM_CAR_ALIGN_RHS, 4.0f);
+		m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, zDiff > 4.4f ? ANIM_STD_CAR_ALIGNHI_DOOR_RHS : ANIM_STD_CAR_ALIGN_DOOR_RHS, 4.0f);
 
 	m_pVehicleAnim->SetFinishCallback(PedAnimAlignCB, this);
 }
@@ -3408,14 +3408,14 @@ CPed::BeingDraggedFromCar(void)
 	PedLineUpPhase lineUpType;
 
 	if (!m_pVehicleAnim) {
-		CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_IDLE_STANCE, 100.0f);
-		animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_CAR_SIT);
+		CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_STD_IDLE, 100.0f);
+		animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CAR_SIT);
 		if (!animAssoc) {
-			animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_CAR_LSIT);
+			animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CAR_SIT_LO);
 			if (!animAssoc) {
-				animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_CAR_SITP);
+				animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CAR_SIT_P);
 				if (!animAssoc)
-					animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_CAR_SITPLO);
+					animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CAR_SIT_P_LO);
 			}
 		}
 		if (animAssoc)
@@ -3423,17 +3423,17 @@ CPed::BeingDraggedFromCar(void)
 
 		if (m_vehDoor == CAR_DOOR_LF || m_vehDoor == CAR_DOOR_LR) {
 			if (bWillBeQuickJacked) {
-				enterAnim = ANIM_CAR_QJACKED;
+				enterAnim = ANIM_STD_QUICKJACKED;
 			} else if (m_pMyVehicle->bLowVehicle) {
-				enterAnim = ANIM_CAR_LJACKED_LHS;
+				enterAnim = ANIM_STD_JACKEDCAR_LO_LHS;
 			} else {
-				enterAnim = ANIM_CAR_JACKED_LHS;
+				enterAnim = ANIM_STD_JACKEDCAR_LHS;
 			}
 		} else if (m_vehDoor == CAR_DOOR_RF || m_vehDoor == CAR_DOOR_RR) {
 			if (m_pMyVehicle->bLowVehicle)
-				enterAnim = ANIM_CAR_LJACKED_RHS;
+				enterAnim = ANIM_STD_JACKEDCAR_LO_RHS;
 			else
-				enterAnim = ANIM_CAR_JACKED_RHS;
+				enterAnim = ANIM_STD_JACKEDCAR_RHS;
 		} else
 			dontRunAnim = true;
 
@@ -3534,16 +3534,16 @@ CPed::SetEnterCar_AllClear(CVehicle *car, uint32 doorNode, uint32 doorFlag)
 #ifdef VC_PED_PORTS
 		// VC checks for handling flag, but we can't do that
 		if(car->GetModelIndex() == MI_SPEEDER)
-			m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_CAR_SIT, 100.0f);
+			m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_CAR_SIT, 100.0f);
 		else
-			m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_DRIVE_BOAT, 100.0f);
+			m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_BOAT_DRIVE, 100.0f);
 
 		PedSetInCarCB(nil, this);
 		bVehExitWillBeInstant = true;
 #else
 
 #ifndef FIX_BUGS
-		m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_DRIVE_BOAT, 100.0f);
+		m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_BOAT_DRIVE, 100.0f);
 #else
 		m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, car->GetDriverAnim(), 100.0f);
 #endif
@@ -3555,15 +3555,15 @@ CPed::SetEnterCar_AllClear(CVehicle *car, uint32 doorNode, uint32 doorFlag)
 	} else {
 		if (zDiff > 4.4f) {
 			if (m_vehDoor == CAR_DOOR_RF || m_vehDoor == CAR_DOOR_RR)
-				m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_CAR_ALIGNHI_RHS, 4.0f);
+				m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_CAR_ALIGNHI_DOOR_RHS, 4.0f);
 			else
-				m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_CAR_ALIGNHI_LHS, 4.0f);
+				m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_CAR_ALIGNHI_DOOR_LHS, 4.0f);
 
 		} else {
 			if (m_vehDoor == CAR_DOOR_RF || m_vehDoor == CAR_DOOR_RR)
-				m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_CAR_ALIGN_RHS, 4.0f);
+				m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_CAR_ALIGN_DOOR_RHS, 4.0f);
 			else
-				m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_CAR_ALIGN_LHS, 4.0f);
+				m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_CAR_ALIGN_DOOR_LHS, 4.0f);
 		}
 		m_pVehicleAnim->SetFinishCallback(PedAnimAlignCB, this);
 		car->AutoPilot.m_nCruiseSpeed = 0;
@@ -3588,7 +3588,7 @@ CPed::EnterCar(void)
 		LineUpPedWithCar(LINE_UP_TO_CAR_START);
 	} else {
 		QuitEnteringCar();
-		SetDie(ANIM_KO_SHOT_FRONT1, 4.0f, 0.0f);
+		SetDie(ANIM_STD_KO_FRONT, 4.0f, 0.0f);
 	}
 }
 
@@ -3601,8 +3601,8 @@ CPed::QuitEnteringCar(void)
 	
 	RestartNonPartialAnims();
 
-	if (!RpAnimBlendClumpGetAssociation(GetClump(), ANIM_IDLE_STANCE))
-		CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_IDLE_STANCE, 100.0f);
+	if (!RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_IDLE))
+		CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_STD_IDLE, 100.0f);
 	
 	if (veh) {
 		if (m_objective == OBJECTIVE_ENTER_CAR_AS_DRIVER || m_nPedState == PED_CARJACK)
@@ -3677,9 +3677,9 @@ CPed::SetExitBoat(CVehicle *boat)
 #ifndef VC_PED_PORTS
 	SetPedState(PED_IDLE);
 	CVector firstPos = GetPosition();
-	CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_IDLE_STANCE, 100.0f);
+	CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_STD_IDLE, 100.0f);
 	if (boat->GetModelIndex() == MI_SPEEDER && boat->IsUpsideDown()) {
-		m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_CAR_CRAWLOUT_RHS, 8.0f);
+		m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_CRAWLOUT_LHS, 8.0f);
 		m_pVehicleAnim->SetFinishCallback(PedSetOutCarCB, this);
 		m_vehDoor = CAR_DOOR_RF;
 		SetPedState(PED_EXIT_CAR);
@@ -3926,7 +3926,7 @@ CPed::SetExitCar(CVehicle *veh, uint32 wantedDoorNode)
 		if (m_pVehicleAnim && m_pVehicleAnim->flags & ASSOC_PARTIAL)
 			m_pVehicleAnim->blendDelta = -1000.0f;
 		SetMoveState(PEDMOVE_NONE);
-		CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_IDLE_STANCE, 100.0f);
+		CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_STD_IDLE, 100.0f);
 		RemoveInCarAnims();
 		veh->AutoPilot.m_nCruiseSpeed = 0;
 		if (teleportNeeded) {
@@ -3966,12 +3966,12 @@ CPed::SetExitCar(CVehicle *veh, uint32 wantedDoorNode)
 				switch (m_vehDoor) {
 					case CAR_DOOR_RF:
 						if (veh->bIsBus) {
-							m_pVehicleAnim = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_COACH_OUT_L);
+							m_pVehicleAnim = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_COACH_GET_OUT_LHS);
 						} else {
 							if (isLow)
-								m_pVehicleAnim = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_CAR_GETOUT_LOW_RHS);
+								m_pVehicleAnim = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_GETOUT_LO_RHS);
 							else
-								m_pVehicleAnim = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_CAR_GETOUT_RHS);
+								m_pVehicleAnim = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_GETOUT_RHS);
 
 							if (addDoorSmoke)
 								AddYardieDoorSmoke(veh, CAR_DOOR_RF);
@@ -3979,21 +3979,21 @@ CPed::SetExitCar(CVehicle *veh, uint32 wantedDoorNode)
 						break;
 					case CAR_DOOR_RR:
 						if (veh->bIsVan) {
-							m_pVehicleAnim = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_VAN_GETOUT);
+							m_pVehicleAnim = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_VAN_GET_OUT_REAR_RHS);
 						} else if (isLow) {
-							m_pVehicleAnim = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_CAR_GETOUT_LOW_RHS);
+							m_pVehicleAnim = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_GETOUT_LO_RHS);
 						} else {
-							m_pVehicleAnim = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_CAR_GETOUT_RHS);
+							m_pVehicleAnim = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_GETOUT_RHS);
 						}
 						break;
 					case CAR_DOOR_LF:
 						if (veh->bIsBus) {
-							m_pVehicleAnim = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_COACH_OUT_L);
+							m_pVehicleAnim = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_COACH_GET_OUT_LHS);
 						} else {
 							if (isLow)
-								m_pVehicleAnim = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_CAR_GETOUT_LOW_LHS);
+								m_pVehicleAnim = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_GETOUT_LO_LHS);
 							else
-								m_pVehicleAnim = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_CAR_GETOUT_LHS);
+								m_pVehicleAnim = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_GETOUT_LHS);
 
 							if (addDoorSmoke)
 								AddYardieDoorSmoke(veh, CAR_DOOR_LF);
@@ -4001,11 +4001,11 @@ CPed::SetExitCar(CVehicle *veh, uint32 wantedDoorNode)
 						break;
 					case CAR_DOOR_LR:
 						if (veh->bIsVan) {
-							m_pVehicleAnim = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_VAN_GETOUT_L);
+							m_pVehicleAnim = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_VAN_GET_OUT_REAR_LHS);
 						} else if (isLow) {
-							m_pVehicleAnim = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_CAR_GETOUT_LOW_LHS);
+							m_pVehicleAnim = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_GETOUT_LO_LHS);
 						} else {
-							m_pVehicleAnim = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_CAR_GETOUT_LHS);
+							m_pVehicleAnim = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_GETOUT_LHS);
 						}
 						break;
 					default:
@@ -4032,9 +4032,9 @@ CPed::SetExitCar(CVehicle *veh, uint32 wantedDoorNode)
 				m_pVehicleAnim->SetFinishCallback(PedAnimStepOutCarCB, this);
 			} else {
 				if (m_vehDoor == CAR_DOOR_RF || m_vehDoor == CAR_DOOR_RR) {
-					m_pVehicleAnim = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_CAR_CRAWLOUT_RHS2);
+					m_pVehicleAnim = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_CRAWLOUT_RHS);
 				} else if (m_vehDoor == CAR_DOOR_LF || m_vehDoor == CAR_DOOR_LR) {
-					m_pVehicleAnim = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_CAR_CRAWLOUT_RHS);
+					m_pVehicleAnim = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_CRAWLOUT_LHS);
 				}
 				m_pVehicleAnim->SetFinishCallback(PedSetOutCarCB, this);
 			}
@@ -4067,7 +4067,7 @@ CPed::ExitCar(void)
 	if (m_pSeekTarget) {
 		// Car is upside down
 		if (m_pMyVehicle->GetUp().z > -0.8f) {
-			if (exitAnim == ANIM_CAR_CLOSE_RHS || exitAnim == ANIM_CAR_CLOSE_LHS || animTime > 0.3f)
+			if (exitAnim == ANIM_STD_CAR_CLOSE_RHS || exitAnim == ANIM_STD_CAR_CLOSE_LHS || animTime > 0.3f)
 				LineUpPedWithCar(LINE_UP_TO_CAR_END);
 			else
 				LineUpPedWithCar((m_pMyVehicle->GetModelIndex() == MI_DODO ? LINE_UP_TO_CAR_END : LINE_UP_TO_CAR_START));
@@ -4086,7 +4086,7 @@ CPed::ExitCar(void)
 			}
 		}
 		if (foundPed && animTime > 0.4f && foundPed->IsPedInControl())
-			foundPed->SetFall(1000, ANIM_KO_SKID_FRONT, 1);
+			foundPed->SetFall(1000, ANIM_STD_HIGHIMPACT_FRONT, 1);
 	}
 }
 
@@ -4248,7 +4248,7 @@ CPed::SetAnimOffsetForEnterOrExitVehicle(void)
 {
 	// FIX: If there were no translations on enter anims, there were overflows all over this function.
 
-	CAnimBlendHierarchy *enterAssoc = CAnimManager::GetAnimAssociation(ASSOCGRP_STD, ANIM_CAR_JACKED_LHS)->hierarchy;
+	CAnimBlendHierarchy *enterAssoc = CAnimManager::GetAnimAssociation(ASSOCGRP_STD, ANIM_STD_JACKEDCAR_LHS)->hierarchy;
 	CAnimBlendSequence *seq = enterAssoc->sequences;
 	CAnimManager::UncompressAnimation(enterAssoc);
 	if (seq->numFrames > 0) {
@@ -4260,7 +4260,7 @@ CPed::SetAnimOffsetForEnterOrExitVehicle(void)
 		}
 	}
 
-	enterAssoc = CAnimManager::GetAnimAssociation(ASSOCGRP_STD, ANIM_CAR_GETIN_LHS)->hierarchy;
+	enterAssoc = CAnimManager::GetAnimAssociation(ASSOCGRP_STD, ANIM_STD_CAR_GET_IN_LHS)->hierarchy;
 	seq = enterAssoc->sequences;
 	CAnimManager::UncompressAnimation(enterAssoc);
 	if (seq->numFrames > 0) {
@@ -4272,7 +4272,7 @@ CPed::SetAnimOffsetForEnterOrExitVehicle(void)
 		}
 	}
 
-	enterAssoc = CAnimManager::GetAnimAssociation(ASSOCGRP_STD, ANIM_CAR_GETIN_LOW_LHS)->hierarchy;
+	enterAssoc = CAnimManager::GetAnimAssociation(ASSOCGRP_STD, ANIM_STD_CAR_GET_IN_LO_LHS)->hierarchy;
 	seq = enterAssoc->sequences;
 	CAnimManager::UncompressAnimation(enterAssoc);
 	if (seq->numFrames > 0) {
@@ -4284,7 +4284,7 @@ CPed::SetAnimOffsetForEnterOrExitVehicle(void)
 		}
 	}
 
-	enterAssoc = CAnimManager::GetAnimAssociation(ASSOCGRP_STD, ANIM_CAR_QJACKED)->hierarchy;
+	enterAssoc = CAnimManager::GetAnimAssociation(ASSOCGRP_STD, ANIM_STD_QUICKJACKED)->hierarchy;
 	seq = enterAssoc->sequences;
 	CAnimManager::UncompressAnimation(enterAssoc);
 	if (seq->numFrames > 0) {
@@ -4296,7 +4296,7 @@ CPed::SetAnimOffsetForEnterOrExitVehicle(void)
 		}
 	}
 
-	enterAssoc = CAnimManager::GetAnimAssociation(ASSOCGRP_STD, ANIM_VAN_GETIN_L)->hierarchy;
+	enterAssoc = CAnimManager::GetAnimAssociation(ASSOCGRP_STD, ANIM_STD_VAN_GET_IN_REAR_LHS)->hierarchy;
 	seq = enterAssoc->sequences;
 	CAnimManager::UncompressAnimation(enterAssoc);
 	if (seq->numFrames > 0) {
@@ -4308,7 +4308,7 @@ CPed::SetAnimOffsetForEnterOrExitVehicle(void)
 		}
 	}
 
-	enterAssoc = CAnimManager::GetAnimAssociation(ASSOCGRP_STD, ANIM_TRAIN_GETOUT)->hierarchy;
+	enterAssoc = CAnimManager::GetAnimAssociation(ASSOCGRP_STD, ANIM_STD_TRAIN_GETOUT)->hierarchy;
 	seq = enterAssoc->sequences;
 	CAnimManager::UncompressAnimation(enterAssoc);
 	if (seq->numFrames > 0) {
@@ -4614,7 +4614,7 @@ CPed::SetEnterTrain(CVehicle *train, uint32 unused)
 	m_pMyVehicle->RegisterReference((CEntity **) &m_pMyVehicle);
 
 	SetPedState(PED_ENTER_TRAIN);
-	m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_TRAIN_GETIN, 4.0f);
+	m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_TRAIN_GETIN, 4.0f);
 	m_pVehicleAnim->SetFinishCallback(PedSetInTrainCB, this);
 	bUsesCollision = false;
 	LineUpPedWithTrain();
@@ -4688,7 +4688,7 @@ CPed::SetExitTrain(CVehicle* train)
 	GetNearestTrainPedPosition(train, exitPos);
 	*/
 	SetPedState(PED_EXIT_TRAIN);
-	m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_TRAIN_GETOUT, 4.0f);
+	m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_TRAIN_GETOUT, 4.0f);
 	m_pVehicleAnim->SetFinishCallback(PedSetOutTrainCB, this);
 	bUsesCollision = false;
 	LineUpPedWithTrain();
@@ -5060,16 +5060,16 @@ CPed::SetDuck(uint32 time)
 		return;
 
 	if (bCrouchWhenShooting && (m_nPedState == PED_ATTACK || m_nPedState == PED_AIM_GUN)) {
-		CAnimBlendAssociation *duckAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_DUCK_LOW);
+		CAnimBlendAssociation *duckAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_DUCK_LOW);
 		if (!duckAssoc || duckAssoc->blendDelta < 0.0f) {
-			CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_DUCK_LOW, 4.0f);
+			CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_DUCK_LOW, 4.0f);
 			bIsDucking = true;
 			m_duckTimer = CTimer::GetTimeInMilliseconds() + time;
 		}
 	} else {
-		CAnimBlendAssociation *duckAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_DUCK_DOWN);
+		CAnimBlendAssociation *duckAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_DUCK_DOWN);
 		if (!duckAssoc || duckAssoc->blendDelta < 0.0f) {
-			CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_DUCK_DOWN, 4.0f);
+			CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_DUCK_DOWN, 4.0f);
 			bIsDucking = true;
 			m_duckTimer = CTimer::GetTimeInMilliseconds() + time;
 		}
@@ -5086,9 +5086,9 @@ CPed::Duck(void)
 void
 CPed::ClearDuck(void)
 {
-	CAnimBlendAssociation *animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_DUCK_DOWN);
+	CAnimBlendAssociation *animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_DUCK_DOWN);
 	if (!animAssoc) {
-		animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_DUCK_LOW);
+		animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_DUCK_LOW);
 
 		if (!animAssoc) {
 			bIsDucking = false;
@@ -5102,9 +5102,9 @@ CPed::ClearDuck(void)
 	if (m_nPedState != PED_ATTACK && m_nPedState != PED_AIM_GUN)
 		return;
 
-	animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_RBLOCK_CSHOOT);
+	animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_RBLOCK_SHOOT);
 	if (!animAssoc || animAssoc->blendDelta < 0.0f) {
-		CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_RBLOCK_CSHOOT, 4.0f);
+		CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_RBLOCK_SHOOT, 4.0f);
 	}
 }
 
@@ -5154,9 +5154,9 @@ CPed::PedAnimDoorCloseRollingCB(CAnimBlendAssociation* animAssoc, void* arg)
 		animAssoc->blendDelta = -1000.0f;
 
 	if (veh->bLowVehicle) {
-		veh->ProcessOpenDoor(CAR_DOOR_LF, ANIM_CAR_ROLLDOOR_LOW, 1.0f);
+		veh->ProcessOpenDoor(CAR_DOOR_LF, ANIM_STD_CAR_CLOSE_DOOR_ROLLING_LO_LHS, 1.0f);
 	} else {
-		veh->ProcessOpenDoor(CAR_DOOR_LF, ANIM_CAR_ROLLDOOR, 1.0f);
+		veh->ProcessOpenDoor(CAR_DOOR_LF, ANIM_STD_CAR_CLOSE_DOOR_ROLLING_LHS, 1.0f);
 	}
 
 	veh->m_nGettingOutFlags &= ~CAR_DOOR_FLAG_LF;
@@ -5235,40 +5235,40 @@ CPed::RemoveInCarAnims(void)
 	CAnimBlendAssociation *animAssoc;
 
 	if (m_pMyVehicle && m_pMyVehicle->bLowVehicle) {
-		animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_DRIVE_LOW_L);
+		animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CAR_DRIVE_LEFT_LO);
 		if (animAssoc)
 			animAssoc->blendDelta = -1000.0f;
-		animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_DRIVE_LOW_R);
+		animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CAR_DRIVE_RIGHT_LO);
 		if (animAssoc)
 			animAssoc->blendDelta = -1000.0f;
-		animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_DRIVEBY_L);
+		animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CAR_DRIVEBY_LEFT);
 		if (animAssoc)
 			animAssoc->blendDelta = -1000.0f;
-		animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_DRIVEBY_R);
+		animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CAR_DRIVEBY_RIGHT);
 		if (animAssoc)
 			animAssoc->blendDelta = -1000.0f;
 	} else {
-		animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_DRIVE_L);
+		animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CAR_DRIVE_LEFT);
 		if (animAssoc)
 			animAssoc->blendDelta = -1000.0f;
-		animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_DRIVE_R);
+		animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CAR_DRIVE_RIGHT);
 		if (animAssoc)
 			animAssoc->blendDelta = -1000.0f;
-		animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_DRIVEBY_L);
+		animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CAR_DRIVEBY_LEFT);
 		if (animAssoc)
 			animAssoc->blendDelta = -1000.0f;
-		animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_DRIVEBY_R);
+		animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CAR_DRIVEBY_RIGHT);
 		if (animAssoc)
 			animAssoc->blendDelta = -1000.0f;
 	}
 
 #ifdef VC_PED_PORTS
-	animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_DRIVE_BOAT);
+	animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_BOAT_DRIVE);
 	if (animAssoc)
 		animAssoc->blendDelta = -1000.0f;
 #endif
 
-	animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_CAR_LB);
+	animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CAR_LOOKBEHIND);
 	if (animAssoc)
 		animAssoc->blendDelta = -1000.0f;
 }
diff --git a/src/peds/PedFight.cpp b/src/peds/PedFight.cpp
index 8625f23e..c03d492a 100644
--- a/src/peds/PedFight.cpp
+++ b/src/peds/PedFight.cpp
@@ -29,30 +29,30 @@ RpClump *flyingClumpTemp;
 
 // This is beta fistfite.dat array. Not used anymore since they're being fetched from fistfite.dat.
 FightMove tFightMoves[NUM_FIGHTMOVES] = {
-	{NUM_ANIMS, 0.0f, 0.0f, 0.0f, 0.0f, HITLEVEL_NULL, 0, 0},
-	{ANIM_PUNCH_R, 0.2f, 8.0f / 30.0f, 0.0f, 0.3f, HITLEVEL_HIGH, 1, 0},
-	{ANIM_FIGHT_IDLE, 0.0f, 0.0f, 0.0f, 0.0f, HITLEVEL_NULL, 0, 0},
-	{ANIM_FIGHT_SH_F, 0.0f, 0.0f, 0.0f, 0.0f, HITLEVEL_NULL, 0, 0},
-	{ANIM_FIGHT_KNEE, 4.0f / 30.0f, 0.2f, 0.0f, 0.6f, HITLEVEL_LOW, 2, 0},
-	{ANIM_FIGHT_HEAD, 4.0f / 30.0f, 0.2f, 0.0f, 0.7f, HITLEVEL_HIGH, 3, 0},
-	{ANIM_FIGHT_PUNCH, 4.0f / 30.0f, 7.0f / 30.0f, 10.0f / 30.0f, 0.4f, HITLEVEL_HIGH, 1, 0},
-	{ANIM_FIGHT_LHOOK, 8.0f / 30.0f, 10.0f / 30.0f, 0.0f, 0.4f, HITLEVEL_HIGH, 3, 0},
-	{ANIM_FIGHT_KICK, 8.0f / 30.0f, 10.0f / 30.0f, 0.0f, 0.5, HITLEVEL_MEDIUM, 2, 0},
-	{ANIM_FIGHT_LONGKICK, 8.0f / 30.0f, 10.0f / 30.0f, 0.0f, 0.5, HITLEVEL_MEDIUM, 4, 0},
-	{ANIM_FIGHT_ROUNDHOUSE, 8.0f / 30.0f, 10.0f / 30.0f, 0.0f, 0.6f, HITLEVEL_MEDIUM, 4, 0},
-	{ANIM_FIGHT_BODYBLOW, 5.0f / 30.0f, 7.0f / 30.0f, 0.0f, 0.35f, HITLEVEL_LOW, 2, 0},
-	{ANIM_KICK_FLOOR, 10.0f / 30.0f, 14.0f / 30.0f, 0.0f, 0.4f, HITLEVEL_GROUND, 1, 0},
-	{ANIM_HIT_FRONT, 0.0f, 0.0f, 0.0f, 0.0f, HITLEVEL_NULL, 0, 0},
-	{ANIM_HIT_BACK, 0.0f, 0.0f, 0.0f, 0.0f, HITLEVEL_NULL, 0, 0},
-	{ANIM_HIT_RIGHT, 0.0f, 0.0f, 0.0f, 0.0f, HITLEVEL_NULL, 0, 0},
-	{ANIM_HIT_LEFT, 0.0f, 0.0f, 0.0f, 0.0f, HITLEVEL_NULL, 0, 0},
-	{ANIM_HIT_BODYBLOW, 0.0f, 0.0f, 0.0f, 0.0f, HITLEVEL_NULL, 0, 0},
-	{ANIM_HIT_CHEST, 0.0f, 0.0f, 0.0f, 0.0f, HITLEVEL_NULL, 0, 0},
-	{ANIM_HIT_HEAD, 0.0f, 0.0f, 0.0f, 0.0f, HITLEVEL_NULL, 0, 0},
-	{ANIM_HIT_WALK, 0.0f, 0.0f, 0.0f, 0.0f, HITLEVEL_NULL, 0, 0},
-	{ANIM_FLOOR_HIT, 0.0f, 0.0f, 0.0f, 0.0f, HITLEVEL_NULL, 0, 0},
-	{ANIM_HIT_BEHIND, 0.0f, 0.0f, 0.0f, 0.0f, HITLEVEL_NULL, 0, 0},
-	{ANIM_FIGHT2_IDLE, 0.0f, 0.0f, 0.0f, 0.0f, HITLEVEL_NULL, 0, 0},
+	{ANIM_STD_NUM, 0.0f, 0.0f, 0.0f, 0.0f, HITLEVEL_NULL, 0, 0},
+	{ANIM_STD_PUNCH, 0.2f, 8.0f / 30.0f, 0.0f, 0.3f, HITLEVEL_HIGH, 1, 0},
+	{ANIM_STD_FIGHT_IDLE, 0.0f, 0.0f, 0.0f, 0.0f, HITLEVEL_NULL, 0, 0},
+	{ANIM_STD_FIGHT_SHUFFLE_F, 0.0f, 0.0f, 0.0f, 0.0f, HITLEVEL_NULL, 0, 0},
+	{ANIM_STD_FIGHT_KNEE, 4.0f / 30.0f, 0.2f, 0.0f, 0.6f, HITLEVEL_LOW, 2, 0},
+	{ANIM_STD_FIGHT_HEAD, 4.0f / 30.0f, 0.2f, 0.0f, 0.7f, HITLEVEL_HIGH, 3, 0},
+	{ANIM_STD_FIGHT_PUNCH, 4.0f / 30.0f, 7.0f / 30.0f, 10.0f / 30.0f, 0.4f, HITLEVEL_HIGH, 1, 0},
+	{ANIM_STD_FIGHT_LHOOK, 8.0f / 30.0f, 10.0f / 30.0f, 0.0f, 0.4f, HITLEVEL_HIGH, 3, 0},
+	{ANIM_STD_FIGHT_KICK, 8.0f / 30.0f, 10.0f / 30.0f, 0.0f, 0.5, HITLEVEL_MEDIUM, 2, 0},
+	{ANIM_STD_FIGHT_LONGKICK, 8.0f / 30.0f, 10.0f / 30.0f, 0.0f, 0.5, HITLEVEL_MEDIUM, 4, 0},
+	{ANIM_STD_FIGHT_ROUNDHOUSE, 8.0f / 30.0f, 10.0f / 30.0f, 0.0f, 0.6f, HITLEVEL_MEDIUM, 4, 0},
+	{ANIM_STD_FIGHT_BODYBLOW, 5.0f / 30.0f, 7.0f / 30.0f, 0.0f, 0.35f, HITLEVEL_LOW, 2, 0},
+	{ANIM_STD_KICKGROUND, 10.0f / 30.0f, 14.0f / 30.0f, 0.0f, 0.4f, HITLEVEL_GROUND, 1, 0},
+	{ANIM_STD_HIT_FRONT, 0.0f, 0.0f, 0.0f, 0.0f, HITLEVEL_NULL, 0, 0},
+	{ANIM_STD_HIT_BACK, 0.0f, 0.0f, 0.0f, 0.0f, HITLEVEL_NULL, 0, 0},
+	{ANIM_STD_HIT_RIGHT, 0.0f, 0.0f, 0.0f, 0.0f, HITLEVEL_NULL, 0, 0},
+	{ANIM_STD_HIT_LEFT, 0.0f, 0.0f, 0.0f, 0.0f, HITLEVEL_NULL, 0, 0},
+	{ANIM_STD_HIT_BODYBLOW, 0.0f, 0.0f, 0.0f, 0.0f, HITLEVEL_NULL, 0, 0},
+	{ANIM_STD_HIT_CHEST, 0.0f, 0.0f, 0.0f, 0.0f, HITLEVEL_NULL, 0, 0},
+	{ANIM_STD_HIT_HEAD, 0.0f, 0.0f, 0.0f, 0.0f, HITLEVEL_NULL, 0, 0},
+	{ANIM_STD_HIT_WALK, 0.0f, 0.0f, 0.0f, 0.0f, HITLEVEL_NULL, 0, 0},
+	{ANIM_STD_HIT_FLOOR, 0.0f, 0.0f, 0.0f, 0.0f, HITLEVEL_NULL, 0, 0},
+	{ANIM_STD_HIT_BEHIND, 0.0f, 0.0f, 0.0f, 0.0f, HITLEVEL_NULL, 0, 0},
+	{ANIM_STD_FIGHT_2IDLE, 0.0f, 0.0f, 0.0f, 0.0f, HITLEVEL_NULL, 0, 0},
 };
 
 static PedOnGroundState
@@ -247,7 +247,7 @@ CPed::SetAttack(CEntity *victim)
 	if (victim && victim->IsPed())
 		victimPed = (CPed*)victim;
 
-	CAnimBlendAssociation *animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_IDLE_ARMED);
+	CAnimBlendAssociation *animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_IDLE_BIGGUN);
 	if (animAssoc) {
 		animAssoc->blendDelta = -1000.0f;
 		animAssoc->flags |= ASSOC_DELETEFADEDOUT;
@@ -256,12 +256,12 @@ CPed::SetAttack(CEntity *victim)
 	if (m_attackTimer > CTimer::GetTimeInMilliseconds() || m_nWaitState == WAITSTATE_SURPRISE)
 		return;
 
-	if (RpAnimBlendClumpGetAssociation(GetClump(), ANIM_HGUN_RELOAD)) {
+	if (RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_HGUN_RELOAD)) {
 		bIsAttacking = false;
 		return;
 	}
 
-	if (RpAnimBlendClumpGetAssociation(GetClump(), ANIM_AK_RELOAD)) {
+	if (RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_AK_RELOAD)) {
 		if (!IsPlayer() || m_nPedState != PED_ATTACK || ((CPlayerPed*)this)->m_bHaveTargetSelected)
 			bIsAttacking = false;
 		else
@@ -351,7 +351,7 @@ CPed::SetAttack(CEntity *victim)
 			SetPedState(PED_ATTACK);
 			SetMoveState(PEDMOVE_NONE);
 			if (bCrouchWhenShooting) {
-				animAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_RBLOCK_CSHOOT, 4.0f);
+				animAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_RBLOCK_SHOOT, 4.0f);
 			} else {
 				float animDelta = 8.0f;
 				if (curWeapon->m_eWeaponFire == WEAPON_FIRE_MELEE)
@@ -418,7 +418,7 @@ CPed::ClearAttackByRemovingAnim(void)
 		weaponAssoc = RpAnimBlendClumpGetAssociation(GetClump(), weapon->m_Anim2ToPlay);
 
 		if (!weaponAssoc && weapon->IsFlagSet(WEAPONFLAG_THROW))
-			weaponAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_WEAPON_THROWU);
+			weaponAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_THROW_UNDER);
 
 		if (!weaponAssoc) {
 			ClearAttack();
@@ -440,27 +440,27 @@ CPed::FinishedAttackCB(CAnimBlendAssociation *attackAssoc, void *arg)
 
 	if (attackAssoc) {
 		switch (attackAssoc->animId) {
-			case ANIM_WEAPON_START_THROW:
+			case ANIM_STD_START_THROW:
 				// what?!
 				if ((!ped->IsPlayer() || ((CPlayerPed*)ped)->m_bHaveTargetSelected) && ped->IsPlayer()) {
 					attackAssoc->blendDelta = -1000.0f;
-					newAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_WEAPON_THROWU);
+					newAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_STD_THROW_UNDER);
 				} else {
 					attackAssoc->blendDelta = -1000.0f;
-					newAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_WEAPON_THROW);
+					newAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_STD_WEAPON_THROW);
 				}
 
 				newAnim->SetFinishCallback(FinishedAttackCB, ped);
 				return;
 
-			case ANIM_FIGHT_PPUNCH:
+			case ANIM_STD_PARTIAL_PUNCH:
 				attackAssoc->blendDelta = -8.0f;
 				attackAssoc->flags |= ASSOC_DELETEFADEDOUT;
 				ped->ClearAttack();
 				return;
 
-			case ANIM_WEAPON_THROW:
-			case ANIM_WEAPON_THROWU:
+			case ANIM_STD_WEAPON_THROW:
+			case ANIM_STD_THROW_UNDER:
 				if (ped->GetWeapon()->m_nAmmoTotal > 0) {
 					currentWeapon = CWeaponInfo::GetWeaponInfo(ped->GetWeapon()->m_eWeaponType);
 					ped->AddWeaponModel(currentWeapon->m_nModelId);
@@ -535,16 +535,16 @@ CPed::Attack(void)
 	weaponAnimAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ourWeapon->m_AnimToPlay);
 	attackShouldContinue = bIsAttacking;
 	reloadAnimAssoc = nil;
-	reloadAnim = NUM_ANIMS;
+	reloadAnim = ANIM_STD_NUM;
 	delayBetweenAnimAndFire = ourWeapon->m_fAnimFrameFire;
 	weaponAnim = ourWeapon->m_AnimToPlay;
 
-	if (weaponAnim == ANIM_WEAPON_HGUN_BODY)
-		reloadAnim = ANIM_HGUN_RELOAD;
-	else if (weaponAnim == ANIM_WEAPON_AK_BODY)
-		reloadAnim = ANIM_AK_RELOAD;
+	if (weaponAnim == ANIM_STD_WEAPON_HGUN_BODY)
+		reloadAnim = ANIM_STD_HGUN_RELOAD;
+	else if (weaponAnim == ANIM_STD_WEAPON_AK_BODY)
+		reloadAnim = ANIM_STD_AK_RELOAD;
 
-	if (reloadAnim != NUM_ANIMS)
+	if (reloadAnim != ANIM_STD_NUM)
 		reloadAnimAssoc = RpAnimBlendClumpGetAssociation(GetClump(), reloadAnim);
 
 	if (bIsDucking)
@@ -566,7 +566,7 @@ CPed::Attack(void)
 
 		// Long throw granade, molotov
 		if (!weaponAnimAssoc && ourWeapon->IsFlagSet(WEAPONFLAG_THROW)) {
-			weaponAnimAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_WEAPON_THROWU);
+			weaponAnimAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_THROW_UNDER);
 			delayBetweenAnimAndFire = 0.2f;
 		}
 
@@ -619,7 +619,7 @@ CPed::Attack(void)
 
 			firePos = GetMatrix() * firePos;
 		} else if (GetWeapon()->m_eWeaponType != WEAPONTYPE_UNARMED) {
-			TransformToNode(firePos, weaponAnimAssoc->animId == ANIM_KICK_FLOOR ? PED_FOOTR : PED_HANDR);
+			TransformToNode(firePos, weaponAnimAssoc->animId == ANIM_STD_KICKGROUND ? PED_FOOTR : PED_HANDR);
 		} else {
 			firePos = GetMatrix() * firePos;
 		}
@@ -636,7 +636,7 @@ CPed::Attack(void)
 		if (GetWeapon()->m_eWeaponState != WEAPONSTATE_MELEE_MADECONTACT) {
 			// If reloading just began, start the animation
 			// Last condition will always return true, even IDA hides it
-			if (GetWeapon()->m_eWeaponState == WEAPONSTATE_RELOADING && reloadAnim != NUM_ANIMS /* && !reloadAnimAssoc*/) {
+			if (GetWeapon()->m_eWeaponState == WEAPONSTATE_RELOADING && reloadAnim != ANIM_STD_NUM /* && !reloadAnimAssoc*/) {
 				CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, reloadAnim, 8.0f);
 				ClearLookFlag();
 				ClearAimFlag();
@@ -646,9 +646,9 @@ CPed::Attack(void)
 				return;
 			}
 		} else {
-			if (weaponAnimAssoc->animId == ANIM_WEAPON_BAT_V || weaponAnimAssoc->animId == ANIM_WEAPON_BAT_H) {
+			if (weaponAnimAssoc->animId == ANIM_STD_WEAPON_BAT_V || weaponAnimAssoc->animId == ANIM_STD_WEAPON_BAT_H) {
 				DMAudio.PlayOneShot(m_audioEntityId, SOUND_WEAPON_BAT_ATTACK, 1.0f);
-			} else if (weaponAnimAssoc->animId == ANIM_FIGHT_PPUNCH) {
+			} else if (weaponAnimAssoc->animId == ANIM_STD_PARTIAL_PUNCH) {
 				DMAudio.PlayOneShot(m_audioEntityId, SOUND_FIGHT_PUNCH_39, 0.0f);
 			}
 
@@ -712,7 +712,7 @@ CPed::Attack(void)
 
 			weaponAnim = weaponAnimAssoc->animId;
 			if (ourWeapon->m_eWeaponFire != WEAPON_FIRE_MELEE || CheckForPedsOnGroundToAttack(this, nil) < PED_ON_THE_FLOOR) {
-				if (weaponAnim != ourWeapon->m_Anim2ToPlay || weaponAnim == ANIM_RBLOCK_CSHOOT) {
+				if (weaponAnim != ourWeapon->m_Anim2ToPlay || weaponAnim == ANIM_STD_RBLOCK_SHOOT) {
 					weaponAnimAssoc->Start(ourWeapon->m_fAnimLoopStart);
 				} else {
 					CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ourWeapon->m_AnimToPlay, 8.0f);
@@ -785,16 +785,16 @@ CPed::StartFightAttack(uint8 buttonPressure)
 	SetPedState(PED_FIGHT);
 	m_fightButtonPressure = 0;
 	RpAnimBlendClumpRemoveAssociations(GetClump(), ASSOC_REPEAT);
-	CAnimBlendAssociation *animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_WALK_START);
+	CAnimBlendAssociation *animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_STARTWALK);
 
 	if (animAssoc) {
 		animAssoc->flags |= ASSOC_DELETEFADEDOUT;
 		animAssoc->blendDelta = -1000.0f;
 	}
 
-	animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_RUN_STOP);
+	animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_RUNSTOP1);
 	if (!animAssoc)
-		animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_RUN_STOP_R);
+		animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_RUNSTOP2);
 
 	if (animAssoc) {
 		animAssoc->flags |= ASSOC_DELETEFADEDOUT;
@@ -805,7 +805,7 @@ CPed::StartFightAttack(uint8 buttonPressure)
 	SetMoveState(PEDMOVE_NONE);
 	m_nStoredMoveState = PEDMOVE_NONE;
 
-	CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_FIGHT_IDLE)->blendAmount = 1.0f;
+	CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_FIGHT_IDLE)->blendAmount = 1.0f;
 
 	CPed *pedOnGround = nil;
 	if (IsPlayer() && CheckForPedsOnGroundToAttack(this, &pedOnGround) > PED_IN_FRONT_OF_ATTACKER) {
@@ -845,7 +845,7 @@ CPed::StartFightDefend(uint8 direction, uint8 hitLevel, uint8 unk)
 			if (hitLevel == HITLEVEL_GROUND) {
 				CAnimBlendAssociation *floorHitAssoc;
 				if (RpAnimBlendClumpGetFirstAssociation(GetClump(), ASSOC_FRONTAL)) {
-					floorHitAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_FLOOR_HIT_F, 8.0f);
+					floorHitAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_HIT_FLOOR_FRONT, 8.0f);
 				} else {
 					floorHitAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, tFightMoves[FIGHTMOVE_HITONFLOOR].animId, 8.0f);
 				}
@@ -867,8 +867,8 @@ CPed::StartFightDefend(uint8 direction, uint8 hitLevel, uint8 unk)
 	} else if (m_nPedState == PED_FALL) {
 		if (hitLevel == HITLEVEL_GROUND && !IsPedHeadAbovePos(-0.3f)) {
 			CAnimBlendAssociation *floorHitAssoc = RpAnimBlendClumpGetFirstAssociation(GetClump(), ASSOC_FRONTAL) ?
-				CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_FLOOR_HIT_F, 8.0f) :
-				CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_FLOOR_HIT, 8.0f);
+				CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_HIT_FLOOR_FRONT, 8.0f) :
+				CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_HIT_FLOOR, 8.0f);
 			if (floorHitAssoc) {
 				floorHitAssoc->flags &= ~ASSOC_FADEOUTWHENDONE;
 				floorHitAssoc->flags |= ASSOC_DELETEFADEDOUT;
@@ -887,16 +887,16 @@ CPed::StartFightDefend(uint8 direction, uint8 hitLevel, uint8 unk)
 					AnimationId shotAnim;
 					switch (direction) {
 						case 1:
-							shotAnim = ANIM_SHOT_LEFT_PARTIAL;
+							shotAnim = ANIM_STD_HITBYGUN_LEFT;
 							break;
 						case 2:
-							shotAnim = ANIM_SHOT_BACK_PARTIAL;
+							shotAnim = ANIM_STD_HITBYGUN_BACK;
 							break;
 						case 3:
-							shotAnim = ANIM_SHOT_RIGHT_PARTIAL;
+							shotAnim = ANIM_STD_HITBYGUN_RIGHT;
 							break;
 						default:
-							shotAnim = ANIM_SHOT_FRONT_PARTIAL;
+							shotAnim = ANIM_STD_HITBYGUN_FRONT;
 							break;
 					}
 					CAnimBlendAssociation *shotAssoc = RpAnimBlendClumpGetAssociation(GetClump(), shotAnim);
@@ -914,16 +914,16 @@ CPed::StartFightDefend(uint8 direction, uint8 hitLevel, uint8 unk)
 #ifndef VC_PED_PORTS
 				switch (direction) {
 					case 1:
-						SetFall(500, ANIM_KO_SPIN_R, false);
+						SetFall(500, ANIM_STD_HIGHIMPACT_LEFT, false);
 						break;
 					case 2:
-						SetFall(500, ANIM_KO_SKID_BACK, false);
+						SetFall(500, ANIM_STD_HIGHIMPACT_BACK, false);
 						break;
 					case 3:
-						SetFall(500, ANIM_KO_SPIN_L, false);
+						SetFall(500, ANIM_STD_HIGHIMPACT_RIGHT, false);
 						break;
 					default:
-						SetFall(500, ANIM_KO_SHOT_STOM, false);
+						SetFall(500, ANIM_STD_KO_SHOT_STOMACH, false);
 						break;
 				}
 #else
@@ -931,30 +931,30 @@ CPed::StartFightDefend(uint8 direction, uint8 hitLevel, uint8 unk)
 				AnimationId hitAnim;
 				switch (direction) {
 					case 1:
-						hitAnim = ANIM_KO_SPIN_R;
+						hitAnim = ANIM_STD_HIGHIMPACT_LEFT;
 						break;
 					case 2:
 						if (CGeneral::GetRandomNumber() & 1) {
 							fall = false;
-							hitAnim = ANIM_HIT_BACK;
+							hitAnim = ANIM_STD_HIT_BACK;
 						} else	{
-							hitAnim = ANIM_KO_SKID_BACK;
+							hitAnim = ANIM_STD_HIGHIMPACT_BACK;
 						}
 						break;
 					case 3:
-						hitAnim = ANIM_KO_SPIN_L;
+						hitAnim = ANIM_STD_HIGHIMPACT_RIGHT;
 						break;
 					default:
 						if (hitLevel == HITLEVEL_LOW) {
-							hitAnim = ANIM_KO_SHOT_STOM;
+							hitAnim = ANIM_STD_KO_SHOT_STOMACH;
 						} else if (CGeneral::GetRandomNumber() & 1) {
 							fall = false;
-							hitAnim = ANIM_HIT_WALK;
+							hitAnim = ANIM_STD_HIT_WALK;
 						} else if (CGeneral::GetRandomNumber() & 1) {
 							fall = false;
-							hitAnim = ANIM_HIT_HEAD;
+							hitAnim = ANIM_STD_HIT_HEAD;
 						} else {
-							hitAnim = ANIM_KO_SHOT_FACE;
+							hitAnim = ANIM_STD_KO_SHOT_FACE;
 						}
 						break;
 				}
@@ -981,15 +981,15 @@ CPed::StartFightDefend(uint8 direction, uint8 hitLevel, uint8 unk)
 				case HITLEVEL_LOW:
 #ifndef VC_PED_PORTS
 					if (direction == 2) {
-						SetFall(1000, ANIM_KO_SKID_BACK, false);
+						SetFall(1000, ANIM_STD_HIGHIMPACT_BACK, false);
 						return;
 					}
 #else
 					if (direction == 2 && (!IsPlayer() || ((CGeneral::GetRandomNumber() & 1) && m_fHealth < 30.0f))) {
-						SetFall(1000, ANIM_KO_SKID_BACK, false);
+						SetFall(1000, ANIM_STD_HIGHIMPACT_BACK, false);
 						return;
 					} else if (direction != 2 && !IsPlayer() && (CGeneral::GetRandomNumber() & 1) && m_fHealth < 30.0f) {
-						SetFall(1000, ANIM_KO_SHOT_STOM, false);
+						SetFall(1000, ANIM_STD_KO_SHOT_STOMACH, false);
 						return;
 					}	
 #endif
@@ -1061,14 +1061,14 @@ CPed::StartFightDefend(uint8 direction, uint8 hitLevel, uint8 unk)
 				SetPedState(PED_FIGHT);
 				m_fightButtonPressure = 0;
 				RpAnimBlendClumpRemoveAssociations(GetClump(), ASSOC_REPEAT);
-				CAnimBlendAssociation *walkStartAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_WALK_START);
+				CAnimBlendAssociation *walkStartAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_STARTWALK);
 				if (walkStartAssoc) {
 					walkStartAssoc->flags |= ASSOC_DELETEFADEDOUT;
 					walkStartAssoc->blendDelta = -1000.0f;
 				}
-				CAnimBlendAssociation *walkStopAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_RUN_STOP);
+				CAnimBlendAssociation *walkStopAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_RUNSTOP1);
 				if (!walkStopAssoc)
-					walkStopAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_RUN_STOP_R);
+					walkStopAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_RUNSTOP2);
 				if (walkStopAssoc) {
 					walkStopAssoc->flags |= ASSOC_DELETEFADEDOUT;
 					walkStopAssoc->blendDelta = -1000.0f;
@@ -1076,7 +1076,7 @@ CPed::StartFightDefend(uint8 direction, uint8 hitLevel, uint8 unk)
 				}
 				SetMoveState(PEDMOVE_NONE);
 				m_nStoredMoveState = PEDMOVE_NONE;
-				CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_FIGHT_IDLE)->blendAmount = 1.0f;
+				CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_FIGHT_IDLE)->blendAmount = 1.0f;
 				CAnimBlendAssociation *moveAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, tFightMoves[m_curFightMove].animId, 8.0f);
 				moveAssoc->SetFinishCallback(FinishFightMoveCB, this);
 				m_fightState = FIGHTSTATE_NO_MOVE;
@@ -1445,22 +1445,22 @@ CPed::EndFight(uint8 endType)
 
 	m_curFightMove = FIGHTMOVE_NULL;
 	RestorePreviousState();
-	CAnimBlendAssociation *animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_FIGHT_IDLE);
+	CAnimBlendAssociation *animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_FIGHT_IDLE);
 	if (animAssoc)
 		animAssoc->flags |= ASSOC_DELETEFADEDOUT;
 
 	switch (endType) {
 		case ENDFIGHT_NORMAL:
-			CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_IDLE_STANCE, 8.0f);
-			CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_FIGHT2_IDLE, 8.0f);
+			CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_STD_IDLE, 8.0f);
+			CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_FIGHT_2IDLE, 8.0f);
 			break;
 		case ENDFIGHT_WITH_A_STEP:
-			CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_IDLE_STANCE, 1.0f);
-			CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_WALK_START, 8.0f);
+			CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_STD_IDLE, 1.0f);
+			CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_STARTWALK, 8.0f);
 			break;
 		case ENDFIGHT_FAST:
-			CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_IDLE_STANCE, 8.0f);
-			CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_FIGHT2_IDLE, 8.0f)->speed = 2.0f;
+			CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_STD_IDLE, 8.0f);
+			CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_FIGHT_2IDLE, 8.0f)->speed = 2.0f;
 			break;
 		default:
 			break;
@@ -1656,7 +1656,7 @@ CPed::FightStrike(CVector &touchedNodePos)
 					|| GetWeapon()->m_eWeaponType != WEAPONTYPE_UNARMED && IsPlayer()
 					|| nearPed->m_pedStats->m_flags & STAT_ONE_HIT_KNOCKDOWN)) {
 
-				nearPed->SetFall(0, (AnimationId)(direction + ANIM_KO_SKID_FRONT), 0);
+				nearPed->SetFall(0, (AnimationId)(direction + ANIM_STD_HIGHIMPACT_FRONT), 0);
 				if (nearPed->m_nPedState == PED_FALL)
 					nearPed->bIsStanding = false;
 			}
@@ -1778,7 +1778,7 @@ CPed::LoadFightData(void)
 			animAssoc = CAnimManager::GetAnimAssociation(ASSOCGRP_STD, animName);
 			tFightMoves[moveId].animId = (AnimationId)animAssoc->animId;
 		} else {
-			tFightMoves[moveId].animId = ANIM_WALK;
+			tFightMoves[moveId].animId = ANIM_STD_WALK;
 		}
 		moveId++;
 	}
@@ -1802,7 +1802,7 @@ CPed::SetInvestigateEvent(eEventType event, CVector2D pos, float distanceToCount
 	if (m_eventType >= EVENT_ICECREAM)
 		m_lookTimer = 0;
 	else
-		CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_HANDSCOWER, 4.0f);
+		CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_HANDSCOWER, 4.0f);
 
 }
 
@@ -1842,7 +1842,7 @@ CPed::InvestigateEvent(void)
 			case EVENT_HIT_AND_RUN_COP:
 
 				if (CTimer::GetTimeInMilliseconds() > m_lookTimer) {
-					animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_ROAD_CROSS);
+					animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_ROADCROSS);
 
 					if (animAssoc) {
 						animAssoc->blendDelta = -8.0f;
@@ -1854,7 +1854,7 @@ CPed::InvestigateEvent(void)
 
 					} else if (CGeneral::GetRandomNumber() & 3) {
 						ClearLookFlag();
-						CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_ROAD_CROSS, 4.0f);
+						CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_ROADCROSS, 4.0f);
 
 						SetLookTimer(CGeneral::GetRandomNumberInRange(1000, 2500));
 						Say(SOUND_PED_CHAT_EVENT);
@@ -1868,16 +1868,16 @@ CPed::InvestigateEvent(void)
 			case EVENT_EXPLOSION:
 
 				if (bHasACamera && CTimer::GetTimeInMilliseconds() > m_lookTimer) {
-					animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_IDLE_CAM);
+					animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_IDLE_CAM);
 					if (!animAssoc)
-						animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_IDLE_STANCE);
+						animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_IDLE);
 
-					if (animAssoc && animAssoc->animId == ANIM_IDLE_CAM) {
-						CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_IDLE_STANCE, 4.0f);
+					if (animAssoc && animAssoc->animId == ANIM_STD_IDLE_CAM) {
+						CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_STD_IDLE, 4.0f);
 						SetLookTimer(CGeneral::GetRandomNumberInRange(1000, 2500));
 
 					} else if (CGeneral::GetRandomNumber() & 3) {
-						CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_IDLE_CAM, 4.0f);
+						CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_IDLE_CAM, 4.0f);
 						SetLookTimer(CGeneral::GetRandomNumberInRange(2500, 5000));
 						Say(SOUND_PED_CHAT_EVENT);
 
@@ -1886,30 +1886,30 @@ CPed::InvestigateEvent(void)
 					}
 
 				} else if (CTimer::GetTimeInMilliseconds() > m_lookTimer) {
-					animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_IDLE_STANCE);
+					animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_IDLE);
 					if (!animAssoc)
-						animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_IDLE_HBHB);
+						animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_IDLE_HBHB);
 
 					if (!animAssoc)
-						animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_XPRESS_SCRATCH);
+						animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_XPRESS_SCRATCH);
 
-					if (animAssoc && animAssoc->animId == ANIM_IDLE_STANCE) {
+					if (animAssoc && animAssoc->animId == ANIM_STD_IDLE) {
 						if (CGeneral::GetRandomNumber() & 1)
-							animToPlay = ANIM_IDLE_HBHB;
+							animToPlay = ANIM_STD_IDLE_HBHB;
 						else
-							animToPlay = ANIM_XPRESS_SCRATCH;
+							animToPlay = ANIM_STD_XPRESS_SCRATCH;
 
 						CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, animToPlay, 4.0f);
 						SetLookTimer(CGeneral::GetRandomNumberInRange(1500, 4000));
 
-					} else if (animAssoc && animAssoc->animId == ANIM_IDLE_HBHB) {
+					} else if (animAssoc && animAssoc->animId == ANIM_STD_IDLE_HBHB) {
 						animAssoc->blendDelta = -8.0f;
 						animAssoc->flags |= ASSOC_DELETEFADEDOUT;
 						if (CGeneral::GetRandomNumber() & 1) {
-							animToPlay = ANIM_IDLE_STANCE;
+							animToPlay = ANIM_STD_IDLE;
 							animGroup = m_animGroup;
 						} else {
-							animToPlay = ANIM_XPRESS_SCRATCH;
+							animToPlay = ANIM_STD_XPRESS_SCRATCH;
 							animGroup = ASSOCGRP_STD;
 						}
 
@@ -1918,10 +1918,10 @@ CPed::InvestigateEvent(void)
 
 					} else {
 						if (CGeneral::GetRandomNumber() & 1) {
-							animToPlay = ANIM_IDLE_STANCE;
+							animToPlay = ANIM_STD_IDLE;
 							animGroup = m_animGroup;
 						} else {
-							animToPlay = ANIM_IDLE_HBHB;
+							animToPlay = ANIM_STD_IDLE_HBHB;
 							animGroup = ASSOCGRP_STD;
 						}
 
@@ -1938,26 +1938,26 @@ CPed::InvestigateEvent(void)
 				if (CTimer::GetTimeInMilliseconds() > m_lookTimer) {
 
 					if (m_lookTimer) {
-						animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_ROAD_CROSS);
+						animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_ROADCROSS);
 
 						if (animAssoc) {
 							animAssoc->blendDelta = -8.0f;
 							animAssoc->flags |= ASSOC_DELETEFADEDOUT;
 							if (m_eventType == EVENT_ICECREAM)
-								animToPlay = ANIM_IDLE_CHAT;
+								animToPlay = ANIM_STD_CHAT;
 							else
-								animToPlay = ANIM_XPRESS_SCRATCH;
+								animToPlay = ANIM_STD_XPRESS_SCRATCH;
 							CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, animToPlay,4.0f);
 							SetLookTimer(CGeneral::GetRandomNumberInRange(2000, 5000));
 
 						} else {
-							animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_IDLE_CHAT);
+							animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CHAT);
 							if (animAssoc) {
 								animAssoc->blendDelta = -8.0f;
 								animAssoc->flags |= ASSOC_DELETEFADEDOUT;
 								ClearInvestigateEvent();
 							} else {
-								animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_XPRESS_SCRATCH);
+								animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_XPRESS_SCRATCH);
 								if (animAssoc) {
 									animAssoc->blendDelta = -8.0f;
 									animAssoc->flags |= ASSOC_DELETEFADEDOUT;
@@ -1966,7 +1966,7 @@ CPed::InvestigateEvent(void)
 							}
 						}
 					} else {
-						CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_ROAD_CROSS, 4.0f);
+						CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_ROADCROSS, 4.0f);
 						SetLookTimer(CGeneral::GetRandomNumberInRange(1000, 2500));
 					}
 				}
@@ -2009,13 +2009,13 @@ CPed::InvestigateEvent(void)
 void
 CPed::ClearInvestigateEvent(void)
 {
-	CAnimBlendAssociation *animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_ROAD_CROSS);
+	CAnimBlendAssociation *animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_ROADCROSS);
 	if (!animAssoc)
-		animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_XPRESS_SCRATCH);
+		animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_XPRESS_SCRATCH);
 	if (!animAssoc)
-		animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_IDLE_HBHB);
+		animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_IDLE_HBHB);
 	if (!animAssoc)
-		animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_IDLE_CHAT);
+		animAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CHAT);
 	if (animAssoc) {
 		animAssoc->blendDelta = -8.0f;
 		animAssoc->flags |= ASSOC_DELETEFADEDOUT;
@@ -2037,7 +2037,7 @@ CPed::InflictDamage(CEntity *damagedBy, eWeaponType method, float damage, ePedPi
 	CPlayerPed *player = FindPlayerPed();
 	float dieDelta = 4.0f;
 	float dieSpeed = 0.0f;
-	AnimationId dieAnim = ANIM_KO_SHOT_FRONT1;
+	AnimationId dieAnim = ANIM_STD_KO_FRONT;
 	bool headShot = false;
 	bool willLinger = false;
 	int random;
@@ -2069,14 +2069,14 @@ CPed::InflictDamage(CEntity *damagedBy, eWeaponType method, float damage, ePedPi
 	if (m_nPedState == PED_FALL || m_nPedState == PED_GETUP) {
 		if (!IsPedHeadAbovePos(-0.3f)) {
 			if (RpAnimBlendClumpGetFirstAssociation(GetClump(), ASSOC_FRONTAL))
-				dieAnim = ANIM_FLOOR_HIT_F;
+				dieAnim = ANIM_STD_HIT_FLOOR_FRONT;
 			else
-				dieAnim = ANIM_FLOOR_HIT;
+				dieAnim = ANIM_STD_HIT_FLOOR;
 			dieDelta *= 2.0f;
 			dieSpeed = 0.5f;
 			detectDieAnim = false;
 		} else if (m_nPedState == PED_FALL) {
-			dieAnim = NUM_ANIMS;
+			dieAnim = ANIM_STD_NUM;
 			detectDieAnim = false;
 		}
 	}
@@ -2088,28 +2088,28 @@ CPed::InflictDamage(CEntity *damagedBy, eWeaponType method, float damage, ePedPi
 
 				if (m_nPedState == PED_FALL) {
 					if (IsPedHeadAbovePos(-0.3f)) {
-						dieAnim = NUM_ANIMS;
+						dieAnim = ANIM_STD_NUM;
 					} else {
 						if (RpAnimBlendClumpGetFirstAssociation(GetClump(), ASSOC_FRONTAL))
-							dieAnim = ANIM_FLOOR_HIT_F;
+							dieAnim = ANIM_STD_HIT_FLOOR_FRONT;
 						else
-							dieAnim = ANIM_FLOOR_HIT;
+							dieAnim = ANIM_STD_HIT_FLOOR;
 						dieDelta = dieDelta * 2.0f;
 						dieSpeed = 0.5f;
 					}
 				} else {
 					switch (direction) {
 						case 0:
-							dieAnim = ANIM_KO_SKID_FRONT;
+							dieAnim = ANIM_STD_HIGHIMPACT_FRONT;
 							break;
 						case 1:
-							dieAnim = ANIM_KO_SPIN_R;
+							dieAnim = ANIM_STD_HIGHIMPACT_LEFT;
 							break;
 						case 2:
-							dieAnim = ANIM_KO_SKID_BACK;
+							dieAnim = ANIM_STD_HIGHIMPACT_BACK;
 							break;
 						case 3:
-							dieAnim = ANIM_KO_SPIN_L;
+							dieAnim = ANIM_STD_HIGHIMPACT_RIGHT;
 							break;
 						default:
 							break;
@@ -2122,28 +2122,28 @@ CPed::InflictDamage(CEntity *damagedBy, eWeaponType method, float damage, ePedPi
 
 				if (m_nPedState == PED_FALL) {
 					if (IsPedHeadAbovePos(-0.3f)) {
-						dieAnim = NUM_ANIMS;
+						dieAnim = ANIM_STD_NUM;
 					} else {
 					    if (RpAnimBlendClumpGetFirstAssociation(GetClump(), ASSOC_FRONTAL))
-							dieAnim = ANIM_FLOOR_HIT_F;
+							dieAnim = ANIM_STD_HIT_FLOOR_FRONT;
 						else
-							dieAnim = ANIM_FLOOR_HIT;
+							dieAnim = ANIM_STD_HIT_FLOOR;
 						dieDelta = dieDelta * 2.0f;
 						dieSpeed = 0.5f;
 					}
 				} else {
 					switch (direction) {
 						case 0:
-							dieAnim = ANIM_KO_SKID_FRONT;
+							dieAnim = ANIM_STD_HIGHIMPACT_FRONT;
 							break;
 						case 1:
-							dieAnim = ANIM_KO_SPIN_R;
+							dieAnim = ANIM_STD_HIGHIMPACT_LEFT;
 							break;
 						case 2:
-							dieAnim = ANIM_KO_SKID_BACK;
+							dieAnim = ANIM_STD_HIGHIMPACT_BACK;
 							break;
 						case 3:
-							dieAnim = ANIM_KO_SPIN_L;
+							dieAnim = ANIM_STD_HIGHIMPACT_RIGHT;
 							break;
 						default:
 							break;
@@ -2183,56 +2183,56 @@ CPed::InflictDamage(CEntity *damagedBy, eWeaponType method, float damage, ePedPi
 					if (method == WEAPONTYPE_SHOTGUN) {
 						switch (direction) {
 							case 0:
-								dieAnim = ANIM_KO_SKID_FRONT;
+								dieAnim = ANIM_STD_HIGHIMPACT_FRONT;
 								break;
 							case 1:
-								dieAnim = ANIM_KO_SPIN_R;
+								dieAnim = ANIM_STD_HIGHIMPACT_LEFT;
 								break;
 							case 2:
-								dieAnim = ANIM_KO_SKID_BACK;
+								dieAnim = ANIM_STD_HIGHIMPACT_BACK;
 								break;
 							case 3:
-								dieAnim = ANIM_KO_SPIN_L;
+								dieAnim = ANIM_STD_HIGHIMPACT_RIGHT;
 								break;
 							default:
 								break;
 						}
 					} else
-						dieAnim = ANIM_KO_SHOT_FRONT1;
+						dieAnim = ANIM_STD_KO_FRONT;
 
 					willLinger = false;
 				} else {
 					switch (pedPiece) {
 						case PEDPIECE_TORSO:
 							willLinger = false;
-							dieAnim = ANIM_KO_SHOT_FRONT1;
+							dieAnim = ANIM_STD_KO_FRONT;
 							break;
 						case PEDPIECE_MID:
 							willLinger = false;
-							dieAnim = ANIM_KO_SHOT_STOM;
+							dieAnim = ANIM_STD_KO_SHOT_STOMACH;
 							break;
 						case PEDPIECE_LEFTARM:
-							dieAnim = ANIM_KO_SHOT_ARML;
+							dieAnim = ANIM_STD_KO_SHOT_ARM_L;
 							RemoveBodyPart(PED_UPPERARML, direction);
 							willLinger = true;
 							break;
 						case PEDPIECE_RIGHTARM:
-							dieAnim = ANIM_KO_SHOT_ARMR;
+							dieAnim = ANIM_STD_KO_SHOT_ARM_R;
 							RemoveBodyPart(PED_UPPERARMR, direction);
 							willLinger = true;
 							break;
 						case PEDPIECE_LEFTLEG:
-							dieAnim = ANIM_KO_SHOT_LEGL;
+							dieAnim = ANIM_STD_KO_SHOT_LEG_L;
 							RemoveBodyPart(PED_UPPERLEGL, direction);
 							willLinger = true;
 							break;
 						case PEDPIECE_RIGHTLEG:
-							dieAnim = ANIM_KO_SHOT_LEGR;
+							dieAnim = ANIM_STD_KO_SHOT_LEG_R;
 							RemoveBodyPart(PED_UPPERLEGR, direction);
 							willLinger = true;
 							break;
 						case PEDPIECE_HEAD:
-							dieAnim = ANIM_KO_SHOT_FACE;
+							dieAnim = ANIM_STD_KO_SHOT_FACE;
 							RemoveBodyPart(PED_HEAD, direction);
 							headShot = true;
 							willLinger = true;
@@ -2272,16 +2272,16 @@ CPed::InflictDamage(CEntity *damagedBy, eWeaponType method, float damage, ePedPi
 
 				switch (direction) {
 					case 0:
-						dieAnim = ANIM_KO_SKID_FRONT;
+						dieAnim = ANIM_STD_HIGHIMPACT_FRONT;
 						break;
 					case 1:
-						dieAnim = ANIM_KO_SPIN_R;
+						dieAnim = ANIM_STD_HIGHIMPACT_LEFT;
 						break;
 					case 2:
-						dieAnim = ANIM_KO_SKID_BACK;
+						dieAnim = ANIM_STD_HIGHIMPACT_BACK;
 						break;
 					case 3:
-						dieAnim = ANIM_KO_SPIN_L;
+						dieAnim = ANIM_STD_HIGHIMPACT_RIGHT;
 						break;
 					default:
 						break;
@@ -2291,7 +2291,7 @@ CPed::InflictDamage(CEntity *damagedBy, eWeaponType method, float damage, ePedPi
 				if (bFireProof)
 					return false;
 
-				dieAnim = ANIM_KO_SHOT_FRONT1;
+				dieAnim = ANIM_STD_KO_FRONT;
 				break;
 			case WEAPONTYPE_RAMMEDBYCAR:
 			case WEAPONTYPE_RUNOVERBYCAR:
@@ -2306,36 +2306,36 @@ CPed::InflictDamage(CEntity *damagedBy, eWeaponType method, float damage, ePedPi
 							if (pedPiece == PEDPIECE_RIGHTARM && random > 1
 								|| pedPiece == PEDPIECE_MID && random == 2)
 						
-								dieAnim = ANIM_KO_SPIN_L;
+								dieAnim = ANIM_STD_HIGHIMPACT_RIGHT;
 							else
-								dieAnim = ANIM_KO_SKID_FRONT;
+								dieAnim = ANIM_STD_HIGHIMPACT_FRONT;
 						} else
-							dieAnim = ANIM_KO_SPIN_R;
+							dieAnim = ANIM_STD_HIGHIMPACT_LEFT;
 
 						break;
 					case 1:
 						if (m_nPedState == PED_DIVE_AWAY)
-							dieAnim = ANIM_KD_LEFT;
+							dieAnim = ANIM_STD_SPINFORWARD_LEFT;
 						else
-							dieAnim = ANIM_KO_SPIN_R;
+							dieAnim = ANIM_STD_HIGHIMPACT_LEFT;
 						break;
 					case 2:
 						if ((pedPiece != PEDPIECE_LEFTARM || random <= 1)
 							&& (pedPiece != PEDPIECE_MID || random != 1)) {
 							if ((pedPiece != PEDPIECE_RIGHTARM || random <= 1)
 								&& (pedPiece != PEDPIECE_MID || random != 2)) {
-								dieAnim = ANIM_KO_SKID_BACK;
+								dieAnim = ANIM_STD_HIGHIMPACT_BACK;
 							} else {
-								dieAnim = ANIM_KD_RIGHT;
+								dieAnim = ANIM_STD_SPINFORWARD_RIGHT;
 							}
 						} else
-							dieAnim = ANIM_KD_LEFT;
+							dieAnim = ANIM_STD_SPINFORWARD_LEFT;
 						break;
 					case 3:
 						if (m_nPedState == PED_DIVE_AWAY)
-							dieAnim = ANIM_KD_RIGHT;
+							dieAnim = ANIM_STD_SPINFORWARD_RIGHT;
 						else
-							dieAnim = ANIM_KO_SPIN_L;
+							dieAnim = ANIM_STD_HIGHIMPACT_RIGHT;
 						break;
 					default:
 						break;
@@ -2353,7 +2353,7 @@ CPed::InflictDamage(CEntity *damagedBy, eWeaponType method, float damage, ePedPi
 				}
 				break;
 			case WEAPONTYPE_DROWNING:
-				dieAnim = ANIM_DROWN;
+				dieAnim = ANIM_STD_DROWN;
 				break;
 			case WEAPONTYPE_FALL:
 				if (bCollisionProof)
@@ -2361,16 +2361,16 @@ CPed::InflictDamage(CEntity *damagedBy, eWeaponType method, float damage, ePedPi
 
 				switch (direction) {
 					case 0:
-						dieAnim = ANIM_KO_SKID_FRONT;
+						dieAnim = ANIM_STD_HIGHIMPACT_FRONT;
 						break;
 					case 1:
-						dieAnim = ANIM_KO_SPIN_R;
+						dieAnim = ANIM_STD_HIGHIMPACT_LEFT;
 						break;
 					case 2:
-						dieAnim = ANIM_KO_SKID_BACK;
+						dieAnim = ANIM_STD_HIGHIMPACT_BACK;
 						break;
 					case 3:
-						dieAnim = ANIM_KO_SPIN_L;
+						dieAnim = ANIM_STD_HIGHIMPACT_RIGHT;
 						break;
 					default:
 						break;
@@ -2460,7 +2460,7 @@ CPed::InflictDamage(CEntity *damagedBy, eWeaponType method, float damage, ePedPi
 		if (player == this)
 			m_pMyVehicle->SetStatus(STATUS_PLAYER_DISABLED);
 
-		SetDie(NUM_ANIMS, 4.0f, 0.0f);
+		SetDie(ANIM_STD_NUM, 4.0f, 0.0f);
 		return true;
 	} else {
 		m_fHealth = 0.0f;
@@ -2663,7 +2663,7 @@ CPed::ApplyHeadShot(eWeaponType weaponType, CVector pos, bool evenOnPlayer)
 
 		// BUG: This condition will always return true. Even fixing it won't work, because these states are unused.
 		// if (m_nPedState != PED_PASSENGER || m_nPedState != PED_TAXI_PASSENGER) {
-			SetDie(ANIM_KO_SHOT_FRONT1, 4.0f, 0.0f);
+			SetDie(ANIM_STD_KO_FRONT, 4.0f, 0.0f);
 		// }
 
 		bBodyPartJustCameOff = true;
@@ -2887,7 +2887,7 @@ CPed::CollideWithPed(CPed *collideWith)
 							} else {
 								SetLookFlag(collideWith, false);
 								TurnBody();
-								animAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_FIGHT_PPUNCH, 8.0f);
+								animAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_PARTIAL_PUNCH, 8.0f);
 								animAssoc->flags |= ASSOC_FADEOUTWHENDONE;
 #ifdef VC_PED_PORTS
 								m_nPedStateTimer = CTimer::GetTimeInMilliseconds() + 2000;
@@ -2912,22 +2912,22 @@ CPed::CollideWithPed(CPed *collideWith)
 					moveForce.z += 0.1f;
 					ApplyMoveForce(moveForce);
 					if (collideWith->m_nMoveState != PEDMOVE_RUN && collideWith->m_nMoveState != PEDMOVE_SPRINT)
-						animToPlay = ANIM_HIT_LEFT;
+						animToPlay = ANIM_STD_HIT_LEFT;
 					else
-						animToPlay = ANIM_SHOT_LEFT_PARTIAL;
+						animToPlay = ANIM_STD_HITBYGUN_LEFT;
 				} else if (heLooksToUs) {
 					CVector moveForce = GetRight() * -1.0f;
 					moveForce.z += 0.1f;
 					ApplyMoveForce(moveForce);
 					if (collideWith->m_nMoveState != PEDMOVE_RUN && collideWith->m_nMoveState != PEDMOVE_SPRINT)
-						animToPlay = ANIM_HIT_RIGHT;
+						animToPlay = ANIM_STD_HIT_RIGHT;
 					else
-						animToPlay = ANIM_SHOT_RIGHT_PARTIAL;
+						animToPlay = ANIM_STD_HITBYGUN_RIGHT;
 				} else {
 					if (collideWith->m_nMoveState != PEDMOVE_RUN && collideWith->m_nMoveState != PEDMOVE_SPRINT)
-						animToPlay = ANIM_HIT_BACK;
+						animToPlay = ANIM_STD_HIT_BACK;
 					else
-						animToPlay = ANIM_SHOT_BACK_PARTIAL;
+						animToPlay = ANIM_STD_HITBYGUN_BACK;
 				}
 
 				if (collideWith->IsPedInControl() && CTimer::GetTimeInMilliseconds() > collideWith->m_nPedStateTimer) {
@@ -2944,17 +2944,17 @@ CPed::CollideWithPed(CPed *collideWith)
 					moveForce.z += 0.1f;
 					ApplyMoveForce(moveForce);
 					if (heLooksToUs)
-						animToPlay = ANIM_KO_SPIN_L;
+						animToPlay = ANIM_STD_HIGHIMPACT_RIGHT;
 					else
-						animToPlay = ANIM_KD_RIGHT;
+						animToPlay = ANIM_STD_SPINFORWARD_RIGHT;
 				} else {
 					CVector moveForce = GetRight();
 					moveForce.z += 0.1f;
 					ApplyMoveForce(moveForce);
 					if (heLooksToUs)
-						animToPlay = ANIM_KO_SPIN_R;
+						animToPlay = ANIM_STD_HIGHIMPACT_LEFT;
 					else
-						animToPlay = ANIM_KD_LEFT;
+						animToPlay = ANIM_STD_SPINFORWARD_LEFT;
 				}
 
 				if (m_nPedState == PED_ATTACK && collideWith->IsPedInControl())
@@ -3209,7 +3209,7 @@ CPed::KillPedWithCar(CVehicle *car, float impulse)
 			damage = 30.0f;
 	
 		InflictDamage(car, WEAPONTYPE_RAMMEDBYCAR, damage, PEDPIECE_TORSO, fallDirection);
-		SetFall(1000, (AnimationId)(fallDirection + ANIM_KO_SKID_FRONT), true);
+		SetFall(1000, (AnimationId)(fallDirection + ANIM_STD_HIGHIMPACT_FRONT), true);
 
 		if (OnGround() && !m_pCollidingEntity &&
 		    (!IsPlayer() || bHasHitWall || car->GetModelIndex() == MI_TRAIN || m_vecDamageNormal.z < -0.8f)) {
diff --git a/src/peds/PlayerPed.cpp b/src/peds/PlayerPed.cpp
index ae981d1d..53187d0b 100644
--- a/src/peds/PlayerPed.cpp
+++ b/src/peds/PlayerPed.cpp
@@ -206,7 +206,7 @@ CPlayerPed::MakeChangesForNewWeapon(int8 weapon)
 void
 CPlayerPed::ReApplyMoveAnims(void)
 {
-	static AnimationId moveAnims[] = { ANIM_WALK, ANIM_RUN, ANIM_SPRINT, ANIM_IDLE_STANCE, ANIM_WALK_START };
+	static AnimationId moveAnims[] = { ANIM_STD_WALK, ANIM_STD_RUN, ANIM_STD_RUNFAST, ANIM_STD_IDLE, ANIM_STD_STARTWALK };
 
 	for(int i = 0; i < ARRAY_SIZE(moveAnims); i++) {
 		CAnimBlendAssociation *curMoveAssoc = RpAnimBlendClumpGetAssociation(GetClump(), moveAnims[i]);
@@ -262,13 +262,13 @@ CPlayerPed::SetInitialState(void)
 void
 CPlayerPed::SetRealMoveAnim(void)
 {
-	CAnimBlendAssociation *curWalkAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_WALK);
-	CAnimBlendAssociation *curRunAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_RUN);
-	CAnimBlendAssociation *curSprintAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_SPRINT);
-	CAnimBlendAssociation *curWalkStartAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_WALK_START);
-	CAnimBlendAssociation *curIdleAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_IDLE_STANCE);
-	CAnimBlendAssociation *curRunStopAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_RUN_STOP);
-	CAnimBlendAssociation *curRunStopRAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_RUN_STOP_R);
+	CAnimBlendAssociation *curWalkAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_WALK);
+	CAnimBlendAssociation *curRunAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_RUN);
+	CAnimBlendAssociation *curSprintAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_RUNFAST);
+	CAnimBlendAssociation *curWalkStartAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_STARTWALK);
+	CAnimBlendAssociation *curIdleAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_IDLE);
+	CAnimBlendAssociation *curRunStopAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_RUNSTOP1);
+	CAnimBlendAssociation *curRunStopRAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_RUNSTOP2);
 	if (bResetWalkAnims) {
 		if (curWalkAssoc)
 			curWalkAssoc->SetCurrentTime(0.0f);
@@ -280,9 +280,9 @@ CPlayerPed::SetRealMoveAnim(void)
 	}
 
 	if (!curIdleAssoc)
-		curIdleAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_IDLE_TIRED);
+		curIdleAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_IDLE_TIRED);
 	if (!curIdleAssoc)
-		curIdleAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_FIGHT_IDLE);
+		curIdleAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_FIGHT_IDLE);
 
 	if (!((curRunStopAssoc && curRunStopAssoc->IsRunning()) || (curRunStopRAssoc && curRunStopRAssoc->IsRunning()))) {
 
@@ -301,10 +301,10 @@ CPlayerPed::SetRealMoveAnim(void)
 			if (!curIdleAssoc) {
 				if (m_fCurrentStamina < 0.0f && !CWorld::TestSphereAgainstWorld(GetPosition(), 0.5f,
 						nil, true, false, false, false, false, false)) {
-					curIdleAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_IDLE_TIRED, 8.0f);
+					curIdleAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_IDLE_TIRED, 8.0f);
 
 				} else {
-					curIdleAssoc = CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_IDLE_STANCE, 8.0f);
+					curIdleAssoc = CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_STD_IDLE, 8.0f);
 				}
 				m_nWaitTimer = CTimer::GetTimeInMilliseconds() + CGeneral::GetRandomNumberInRange(2500, 4000);
 			}
@@ -315,25 +315,25 @@ CPlayerPed::SetRealMoveAnim(void)
 			if (!curIdleAssoc) {
 				if (m_fCurrentStamina < 0.0f && !CWorld::TestSphereAgainstWorld(GetPosition(), 0.5f,
 						nil, true, false, false, false, false, false)) {
-					curIdleAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_IDLE_TIRED, 4.0f);
+					curIdleAssoc = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_IDLE_TIRED, 4.0f);
 					
 				} else {
-					curIdleAssoc = CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_IDLE_STANCE, 4.0f);
+					curIdleAssoc = CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_STD_IDLE, 4.0f);
 				}
 
 				m_nWaitTimer = CTimer::GetTimeInMilliseconds() + CGeneral::GetRandomNumberInRange(2500, 4000);
 			}
 
-			if (m_fCurrentStamina > 0.0f && curIdleAssoc->animId == ANIM_IDLE_TIRED) {
-				CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_IDLE_STANCE, 4.0f);
+			if (m_fCurrentStamina > 0.0f && curIdleAssoc->animId == ANIM_STD_IDLE_TIRED) {
+				CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_STD_IDLE, 4.0f);
 
 			} else if (m_nPedState != PED_FIGHT) {
-				if (m_fCurrentStamina < 0.0f && curIdleAssoc->animId != ANIM_IDLE_TIRED
+				if (m_fCurrentStamina < 0.0f && curIdleAssoc->animId != ANIM_STD_IDLE_TIRED
 					&& !CWorld::TestSphereAgainstWorld(GetPosition(), 0.5f, nil, true, false, false, false, false, false)) {
-					CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_IDLE_TIRED, 4.0f);
+					CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_IDLE_TIRED, 4.0f);
 
-				} else if (curIdleAssoc->animId != ANIM_IDLE_STANCE) {
-					CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_IDLE_STANCE, 4.0f);
+				} else if (curIdleAssoc->animId != ANIM_STD_IDLE) {
+					CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_STD_IDLE, 4.0f);
 				}
 			}
 			m_nMoveState = PEDMOVE_STILL;
@@ -344,7 +344,7 @@ CPlayerPed::SetRealMoveAnim(void)
 					curWalkStartAssoc->blendAmount = 1.0f;
 					curWalkStartAssoc->blendDelta = 0.0f;
 				} else {
-					curWalkStartAssoc = CAnimManager::AddAnimation(GetClump(), m_animGroup, ANIM_WALK_START);
+					curWalkStartAssoc = CAnimManager::AddAnimation(GetClump(), m_animGroup, ANIM_STD_STARTWALK);
 				}
 				if (curWalkAssoc)
 					curWalkAssoc->SetCurrentTime(0.0f);
@@ -352,8 +352,8 @@ CPlayerPed::SetRealMoveAnim(void)
 					curRunAssoc->SetCurrentTime(0.0f);
 
 				delete curIdleAssoc;
-				delete RpAnimBlendClumpGetAssociation(GetClump(), ANIM_IDLE_TIRED);
-				delete RpAnimBlendClumpGetAssociation(GetClump(), ANIM_FIGHT_IDLE);
+				delete RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_IDLE_TIRED);
+				delete RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_FIGHT_IDLE);
 				delete curSprintAssoc;
 
 				curSprintAssoc = nil;
@@ -368,11 +368,11 @@ CPlayerPed::SetRealMoveAnim(void)
 				RestoreHeadingRate();
 			}
 			if (!curWalkAssoc) {
-				curWalkAssoc = CAnimManager::AddAnimation(GetClump(), m_animGroup, ANIM_WALK);
+				curWalkAssoc = CAnimManager::AddAnimation(GetClump(), m_animGroup, ANIM_STD_WALK);
 				curWalkAssoc->blendAmount = 0.0f;
 			}
 			if (!curRunAssoc) {
-				curRunAssoc = CAnimManager::AddAnimation(GetClump(), m_animGroup, ANIM_RUN);
+				curRunAssoc = CAnimManager::AddAnimation(GetClump(), m_animGroup, ANIM_STD_RUN);
 				curRunAssoc->blendAmount = 0.0f;
 			}
 			if (curWalkStartAssoc && !(curWalkStartAssoc->IsRunning())) {
@@ -399,9 +399,9 @@ CPlayerPed::SetRealMoveAnim(void)
 					if (m_fMoveSpeed < 0.4f) {
 						AnimationId runStopAnim;
 						if (curSprintAssoc->currentTime / curSprintAssoc->hierarchy->totalLength < 0.5) // double
-							runStopAnim = ANIM_RUN_STOP;
+							runStopAnim = ANIM_STD_RUNSTOP1;
 						else
-							runStopAnim = ANIM_RUN_STOP_R;
+							runStopAnim = ANIM_STD_RUNSTOP2;
 						CAnimBlendAssociation* newRunStopAssoc = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, runStopAnim);
 						newRunStopAssoc->blendAmount = 1.0f;
 						newRunStopAssoc->SetDeleteCallback(RestoreHeadingRateCB, this);
@@ -444,7 +444,7 @@ CPlayerPed::SetRealMoveAnim(void)
 					// Transition between run-sprint
 					curWalkAssoc->blendAmount = 0.0f;
 					curRunAssoc->blendAmount = 1.0f;
-					curSprintAssoc = CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_SPRINT, 2.0f);
+					curSprintAssoc = CAnimManager::BlendAnimation(GetClump(), m_animGroup, ANIM_STD_RUNFAST, 2.0f);
 				}
 				UseSprintEnergy();
 			} else {
@@ -539,14 +539,14 @@ CPlayerPed::DoesTargetHaveToBeBroken(CVector target, CWeapon *weaponUsed)
 void
 CPlayerPed::RunningLand(CPad *padUsed)
 {
-	CAnimBlendAssociation *landAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_FALL_LAND);
+	CAnimBlendAssociation *landAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_FALL_LAND);
 	if (landAssoc && landAssoc->currentTime == 0.0f && m_fMoveSpeed > 1.5f
 		&& padUsed && (padUsed->GetPedWalkLeftRight() != 0.0f || padUsed->GetPedWalkUpDown() != 0.0f)) {
 
 		landAssoc->blendDelta = -1000.0f;
 		landAssoc->flags |= ASSOC_DELETEFADEDOUT;
 
-		CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_JUMP_LAND)->SetFinishCallback(FinishJumpCB, this);
+		CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_JUMP_LAND)->SetFinishCallback(FinishJumpCB, this);
 
 		if (m_nPedState == PED_JUMP)
 			RestorePreviousState();
@@ -1009,7 +1009,7 @@ CPlayerPed::ProcessPlayerWeapon(CPad *padUsed)
 					TheCamera.SetNewPlayerWeaponMode(CCam::MODE_M16_1STPERSON, 0, 0);
 
 				m_fMoveSpeed = 0.0f;
-				CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_IDLE_STANCE, 1000.0f);
+				CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_IDLE, 1000.0f);
 			}
 			if (GetWeapon()->m_eWeaponType == WEAPONTYPE_ROCKETLAUNCHER || GetWeapon()->m_eWeaponType == WEAPONTYPE_SNIPERRIFLE
 				|| TheCamera.PlayerWeaponMode.Mode == CCam::MODE_M16_1STPERSON)
@@ -1280,24 +1280,24 @@ CPlayerPed::ProcessControl(void)
 	}
 	if (m_nPedState == PED_DRIVING && m_objective != OBJECTIVE_LEAVE_CAR) {
 		if (m_pMyVehicle->IsCar() && ((CAutomobile*)m_pMyVehicle)->Damage.GetDoorStatus(DOOR_FRONT_LEFT) == DOOR_STATUS_SWINGING) {
-			CAnimBlendAssociation *rollDoorAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_CAR_ROLLDOOR);
+			CAnimBlendAssociation *rollDoorAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CAR_CLOSE_DOOR_ROLLING_LHS);
 
-			if (m_pMyVehicle->m_nGettingOutFlags & CAR_DOOR_FLAG_LF || rollDoorAssoc || (rollDoorAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_CAR_ROLLDOOR_LOW))) {
+			if (m_pMyVehicle->m_nGettingOutFlags & CAR_DOOR_FLAG_LF || rollDoorAssoc || (rollDoorAssoc = RpAnimBlendClumpGetAssociation(GetClump(), ANIM_STD_CAR_CLOSE_DOOR_ROLLING_LO_LHS))) {
 				if (rollDoorAssoc)
-					m_pMyVehicle->ProcessOpenDoor(CAR_DOOR_LF, ANIM_CAR_ROLLDOOR, rollDoorAssoc->currentTime);
+					m_pMyVehicle->ProcessOpenDoor(CAR_DOOR_LF, ANIM_STD_CAR_CLOSE_DOOR_ROLLING_LHS, rollDoorAssoc->currentTime);
 
 			} else {
 				// These comparisons are wrong, they return uint16
 				if (padUsed && (padUsed->GetAccelerate() != 0.0f || padUsed->GetSteeringLeftRight() != 0.0f || padUsed->GetBrake() != 0.0f)) {
 					if (rollDoorAssoc)
-						m_pMyVehicle->ProcessOpenDoor(CAR_DOOR_LF, ANIM_CAR_ROLLDOOR, rollDoorAssoc->currentTime);
+						m_pMyVehicle->ProcessOpenDoor(CAR_DOOR_LF, ANIM_STD_CAR_CLOSE_DOOR_ROLLING_LHS, rollDoorAssoc->currentTime);
 
 				} else {
 					m_pMyVehicle->m_nGettingOutFlags |= CAR_DOOR_FLAG_LF;
 					if (m_pMyVehicle->bLowVehicle)
-						rollDoorAssoc = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_CAR_ROLLDOOR_LOW);
+						rollDoorAssoc = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_CAR_CLOSE_DOOR_ROLLING_LO_LHS);
 					else
-						rollDoorAssoc = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_CAR_ROLLDOOR);
+						rollDoorAssoc = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_STD_CAR_CLOSE_DOOR_ROLLING_LHS);
 
 					rollDoorAssoc->SetFinishCallback(PedAnimDoorCloseRollingCB, this);
 				}
diff --git a/src/peds/Population.cpp b/src/peds/Population.cpp
index 053cf5e4..a0bf8be6 100644
--- a/src/peds/Population.cpp
+++ b/src/peds/Population.cpp
@@ -847,7 +847,7 @@ CPopulation::AddPedInCar(CVehicle* car)
 	}
 #else
 	{
-		newPed->m_pVehicleAnim = CAnimManager::BlendAnimation(newPed->GetClump(), ASSOCGRP_STD, ANIM_CAR_SIT, 100.0f);
+		newPed->m_pVehicleAnim = CAnimManager::BlendAnimation(newPed->GetClump(), ASSOCGRP_STD, ANIM_STD_CAR_SIT, 100.0f);
 	}
 #endif
 	
diff --git a/src/render/WaterCannon.cpp b/src/render/WaterCannon.cpp
index f54b31b9..5cc9d0b8 100644
--- a/src/render/WaterCannon.cpp
+++ b/src/render/WaterCannon.cpp
@@ -231,7 +231,7 @@ void CWaterCannon::PushPeds(void)
 							ped->m_vecMoveSpeed.x = (0.6f * m_avecVelocity[j].x + ped->m_vecMoveSpeed.x) * 0.5f;
 							ped->m_vecMoveSpeed.y = (0.6f * m_avecVelocity[j].y + ped->m_vecMoveSpeed.y) * 0.5f;
 							
-							ped->SetFall(2000, AnimationId(ANIM_KO_SKID_FRONT + localDir), 0);
+							ped->SetFall(2000, AnimationId(ANIM_STD_HIGHIMPACT_FRONT + localDir), 0);
 							
 							CFire *fire = ped->m_pFire;
 							if ( fire )
diff --git a/src/vehicles/Automobile.cpp b/src/vehicles/Automobile.cpp
index 7e8c4702..4863b945 100644
--- a/src/vehicles/Automobile.cpp
+++ b/src/vehicles/Automobile.cpp
@@ -3058,21 +3058,21 @@ CAutomobile::DoDriveByShootings(void)
 
 	if(lookingLeft || lookingRight){
 		if(lookingLeft){
-			anim = RpAnimBlendClumpGetAssociation(pDriver->GetClump(), ANIM_DRIVEBY_R);
+			anim = RpAnimBlendClumpGetAssociation(pDriver->GetClump(), ANIM_STD_CAR_DRIVEBY_RIGHT);
 			if(anim)
 				anim->blendDelta = -1000.0f;
-			anim = RpAnimBlendClumpGetAssociation(pDriver->GetClump(), ANIM_DRIVEBY_L);
+			anim = RpAnimBlendClumpGetAssociation(pDriver->GetClump(), ANIM_STD_CAR_DRIVEBY_LEFT);
 			if(anim == nil || anim->blendDelta < 0.0f)
-				CAnimManager::AddAnimation(pDriver->GetClump(), ASSOCGRP_STD, ANIM_DRIVEBY_L);
+				CAnimManager::AddAnimation(pDriver->GetClump(), ASSOCGRP_STD, ANIM_STD_CAR_DRIVEBY_LEFT);
 			else
 				anim->SetRun();
 		}else if(pDriver->m_pMyVehicle->pPassengers[0] == nil || TheCamera.Cams[TheCamera.ActiveCam].Mode == CCam::MODE_1STPERSON){
-			anim = RpAnimBlendClumpGetAssociation(pDriver->GetClump(), ANIM_DRIVEBY_L);
+			anim = RpAnimBlendClumpGetAssociation(pDriver->GetClump(), ANIM_STD_CAR_DRIVEBY_LEFT);
 			if(anim)
 				anim->blendDelta = -1000.0f;
-			anim = RpAnimBlendClumpGetAssociation(pDriver->GetClump(), ANIM_DRIVEBY_R);
+			anim = RpAnimBlendClumpGetAssociation(pDriver->GetClump(), ANIM_STD_CAR_DRIVEBY_RIGHT);
 			if(anim == nil || anim->blendDelta < 0.0f)
-				CAnimManager::AddAnimation(pDriver->GetClump(), ASSOCGRP_STD, ANIM_DRIVEBY_R);
+				CAnimManager::AddAnimation(pDriver->GetClump(), ASSOCGRP_STD, ANIM_STD_CAR_DRIVEBY_RIGHT);
 			else
 				anim->SetRun();
 		}
@@ -3083,10 +3083,10 @@ CAutomobile::DoDriveByShootings(void)
 		}
 	}else{
 		weapon->Reload();
-		anim = RpAnimBlendClumpGetAssociation(pDriver->GetClump(), ANIM_DRIVEBY_L);
+		anim = RpAnimBlendClumpGetAssociation(pDriver->GetClump(), ANIM_STD_CAR_DRIVEBY_LEFT);
 		if(anim)
 			anim->blendDelta = -1000.0f;
-		anim = RpAnimBlendClumpGetAssociation(pDriver->GetClump(), ANIM_DRIVEBY_R);
+		anim = RpAnimBlendClumpGetAssociation(pDriver->GetClump(), ANIM_STD_CAR_DRIVEBY_RIGHT);
 		if(anim)
 			anim->blendDelta = -1000.0f;
 	}
@@ -3094,11 +3094,11 @@ CAutomobile::DoDriveByShootings(void)
 	// TODO: what is this?
 	if(!lookingLeft && m_weaponDoorTimerLeft > 0.0f){
 		m_weaponDoorTimerLeft = Max(m_weaponDoorTimerLeft - CTimer::GetTimeStep()*0.1f, 0.0f);
-		ProcessOpenDoor(CAR_DOOR_LF, NUM_ANIMS, m_weaponDoorTimerLeft);
+		ProcessOpenDoor(CAR_DOOR_LF, ANIM_STD_NUM, m_weaponDoorTimerLeft);
 	}
 	if(!lookingRight && m_weaponDoorTimerRight > 0.0f){
 		m_weaponDoorTimerRight = Max(m_weaponDoorTimerRight - CTimer::GetTimeStep()*0.1f, 0.0f);
-		ProcessOpenDoor(CAR_DOOR_RF, NUM_ANIMS, m_weaponDoorTimerRight);
+		ProcessOpenDoor(CAR_DOOR_RF, ANIM_STD_NUM, m_weaponDoorTimerRight);
 	}
 }
 
@@ -3736,55 +3736,55 @@ CAutomobile::ProcessOpenDoor(uint32 component, uint32 anim, float time)
 		return;
 
 	switch(anim){
-	case ANIM_CAR_QJACK:
-	case ANIM_CAR_OPEN_LHS:
-	case ANIM_CAR_OPEN_RHS:
+	case ANIM_STD_QUICKJACK:
+	case ANIM_STD_CAR_OPEN_DOOR_LHS:
+	case ANIM_STD_CAR_OPEN_DOOR_RHS:
 		ProcessDoorOpenAnimation(this, component, door, time, 0.66f, 0.8f);
 		break;
-	case ANIM_CAR_CLOSEDOOR_LHS:
-	case ANIM_CAR_CLOSEDOOR_LOW_LHS:
-	case ANIM_CAR_CLOSEDOOR_RHS:
-	case ANIM_CAR_CLOSEDOOR_LOW_RHS:
+	case ANIM_STD_CAR_CLOSE_DOOR_LHS:
+	case ANIM_STD_CAR_CLOSE_DOOR_LO_LHS:
+	case ANIM_STD_CAR_CLOSE_DOOR_RHS:
+	case ANIM_STD_CAR_CLOSE_DOOR_LO_RHS:
 		ProcessDoorCloseAnimation(this, component, door, time, 0.2f, 0.63f);
 		break;
-	case ANIM_CAR_ROLLDOOR:
-	case ANIM_CAR_ROLLDOOR_LOW:
+	case ANIM_STD_CAR_CLOSE_DOOR_ROLLING_LHS:
+	case ANIM_STD_CAR_CLOSE_DOOR_ROLLING_LO_LHS:
 		ProcessDoorOpenCloseAnimation(this, component, door, time, 0.1f, 0.6f, 0.95f);
 		break;
-	case ANIM_CAR_GETOUT_LHS:
-	case ANIM_CAR_GETOUT_LOW_LHS:
-	case ANIM_CAR_GETOUT_RHS:
-	case ANIM_CAR_GETOUT_LOW_RHS:
+	case ANIM_STD_GETOUT_LHS:
+	case ANIM_STD_GETOUT_LO_LHS:
+	case ANIM_STD_GETOUT_RHS:
+	case ANIM_STD_GETOUT_LO_RHS:
 		ProcessDoorOpenAnimation(this, component, door, time, 0.06f, 0.43f);
 		break;
-	case ANIM_CAR_CLOSE_LHS:
-	case ANIM_CAR_CLOSE_RHS:
+	case ANIM_STD_CAR_CLOSE_LHS:
+	case ANIM_STD_CAR_CLOSE_RHS:
 		ProcessDoorCloseAnimation(this, component, door, time, 0.1f, 0.23f);
 		break;
-	case ANIM_CAR_PULLOUT_RHS:
-	case ANIM_CAR_PULLOUT_LOW_RHS:
+	case ANIM_STD_CAR_PULL_OUT_PED_RHS:
+	case ANIM_STD_CAR_PULL_OUT_PED_LO_RHS:
 		OpenDoor(component, door, 1.0f);
 		break;
-	case ANIM_COACH_OPEN_L:
-	case ANIM_COACH_OPEN_R:
+	case ANIM_STD_COACH_OPEN_LHS:
+	case ANIM_STD_COACH_OPEN_RHS:
 		ProcessDoorOpenAnimation(this, component, door, time, 0.66f, 0.8f);
 		break;
-	case ANIM_COACH_OUT_L:
+	case ANIM_STD_COACH_GET_OUT_LHS:
 		ProcessDoorOpenAnimation(this, component, door, time, 0.0f, 0.3f);
 		break;
-	case ANIM_VAN_OPEN_L:
-	case ANIM_VAN_OPEN:
+	case ANIM_STD_VAN_OPEN_DOOR_REAR_LHS:
+	case ANIM_STD_VAN_OPEN_DOOR_REAR_RHS:
 		ProcessDoorOpenAnimation(this, component, door, time, 0.37f, 0.55f);
 		break;
-	case ANIM_VAN_CLOSE_L:
-	case ANIM_VAN_CLOSE:
+	case ANIM_STD_VAN_CLOSE_DOOR_REAR_LHS:
+	case ANIM_STD_VAN_CLOSE_DOOR_REAR_RHS:
 		ProcessDoorCloseAnimation(this, component, door, time, 0.5f, 0.8f);
 		break;
-	case ANIM_VAN_GETOUT_L:
-	case ANIM_VAN_GETOUT:
+	case ANIM_STD_VAN_GET_OUT_REAR_LHS:
+	case ANIM_STD_VAN_GET_OUT_REAR_RHS:
 		ProcessDoorOpenAnimation(this, component, door, time, 0.5f, 0.6f);
 		break;
-	case NUM_ANIMS:
+	case ANIM_STD_NUM:
 		OpenDoor(component, door, time);
 		break;
 	}
@@ -3879,7 +3879,7 @@ CAutomobile::BlowUpCar(CEntity *culprit)
 			if(!pDriver->IsPlayer())
 				pDriver->FlagToDestroyWhenNextProcessed();
 		}else
-			pDriver->SetDie(ANIM_KO_SHOT_FRONT1, 4.0f, 0.0f);
+			pDriver->SetDie(ANIM_STD_KO_FRONT, 4.0f, 0.0f);
 	}
 	for(i = 0; i < m_nNumMaxPassengers; i++){
 		if(pPassengers[i]){
@@ -3889,7 +3889,7 @@ CAutomobile::BlowUpCar(CEntity *culprit)
 				if(!pPassengers[i]->IsPlayer())
 					pPassengers[i]->FlagToDestroyWhenNextProcessed();
 			}else
-				pPassengers[i]->SetDie(ANIM_KO_SHOT_FRONT1, 4.0f, 0.0f);
+				pPassengers[i]->SetDie(ANIM_STD_KO_FRONT, 4.0f, 0.0f);
 		}
 	}
 
diff --git a/src/vehicles/Vehicle.h b/src/vehicles/Vehicle.h
index a6a4f815..5caad727 100644
--- a/src/vehicles/Vehicle.h
+++ b/src/vehicles/Vehicle.h
@@ -276,7 +276,7 @@ public:
 #endif
 	CVehicleModelInfo* GetModelInfo() { return (CVehicleModelInfo*)CModelInfo::GetModelInfo(GetModelIndex()); }
 	bool IsTaxi(void) { return GetModelIndex() == MI_TAXI || GetModelIndex() == MI_CABBIE || GetModelIndex() == MI_BORGNINE; }
-	AnimationId GetDriverAnim(void) { return IsCar() && bLowVehicle ? ANIM_CAR_LSIT : (IsBoat() && GetModelIndex() != MI_SPEEDER ? ANIM_DRIVE_BOAT : ANIM_CAR_SIT); }
+	AnimationId GetDriverAnim(void) { return IsCar() && bLowVehicle ? ANIM_STD_CAR_SIT_LO : (IsBoat() && GetModelIndex() != MI_SPEEDER ? ANIM_STD_BOAT_DRIVE : ANIM_STD_CAR_SIT); }
 
 	static bool bWheelsOnlyCheat;
 	static bool bAllDodosCheat;
diff --git a/src/weapons/BulletInfo.cpp b/src/weapons/BulletInfo.cpp
index e87a7407..bfe27e18 100644
--- a/src/weapons/BulletInfo.cpp
+++ b/src/weapons/BulletInfo.cpp
@@ -121,7 +121,7 @@ void CBulletInfo::Update(void)
 					if (pPed->DoesLOSBulletHitPed(point)) {
 						if (pPed->IsPedInControl() && !pPed->bIsDucking) {
 							pPed->ClearAttackByRemovingAnim();
-							CAnimBlendAssociation* pAnim = CAnimManager::AddAnimation(pPed->GetClump(), ASSOCGRP_STD, ANIM_SHOT_FRONT_PARTIAL);
+							CAnimBlendAssociation* pAnim = CAnimManager::AddAnimation(pPed->GetClump(), ASSOCGRP_STD, ANIM_STD_HITBYGUN_FRONT);
 							pAnim->SetBlend(0.0f, 8.0f);
 						}
 						pPed->InflictDamage(pBullet->m_pSource, pBullet->m_eWeaponType, pBullet->m_nDamage, (ePedPieceTypes)point.pieceB, pPed->GetLocalDirection(pPed->GetPosition() - point.point));
@@ -146,9 +146,9 @@ void CBulletInfo::Update(void)
 					if (pPed->GetPedState() == PED_DEAD) {
 						CAnimBlendAssociation* pAnim;
 						if (RpAnimBlendClumpGetFirstAssociation(pPed->GetClump(), ASSOC_FRONTAL))
-							pAnim = CAnimManager::BlendAnimation(pPed->GetClump(), ASSOCGRP_STD, ANIM_FLOOR_HIT_F, 8.0f);
+							pAnim = CAnimManager::BlendAnimation(pPed->GetClump(), ASSOCGRP_STD, ANIM_STD_HIT_FLOOR_FRONT, 8.0f);
 						else
-							pAnim = CAnimManager::BlendAnimation(pPed->GetClump(), ASSOCGRP_STD, ANIM_FLOOR_HIT, 8.0f);
+							pAnim = CAnimManager::BlendAnimation(pPed->GetClump(), ASSOCGRP_STD, ANIM_STD_HIT_FLOOR, 8.0f);
 						if (pAnim) {
 							pAnim->SetCurrentTime(0.0f);
 							pAnim->flags |= ASSOC_RUNNING;
diff --git a/src/weapons/Weapon.cpp b/src/weapons/Weapon.cpp
index a987a4c7..dab510be 100644
--- a/src/weapons/Weapon.cpp
+++ b/src/weapons/Weapon.cpp
@@ -473,9 +473,9 @@ CWeapon::FireMelee(CEntity *shooter, CVector &fireSource)
 									victimPed->ApplyMoveForce(posOffset.x*-5.0f, posOffset.y*-5.0f, 3.0f);
 
 									if ( isBat && victimPed->IsPlayer() )
-										victimPed->SetFall(3000, AnimationId(ANIM_KO_SKID_FRONT + localDir), false);
+										victimPed->SetFall(3000, AnimationId(ANIM_STD_HIGHIMPACT_FRONT + localDir), false);
 									else
-										victimPed->SetFall(1500, AnimationId(ANIM_KO_SKID_FRONT + localDir), false);
+										victimPed->SetFall(1500, AnimationId(ANIM_STD_HIGHIMPACT_FRONT + localDir), false);
 
 									shooterPed->m_pSeekTarget = victimPed;
 									shooterPed->m_pSeekTarget->RegisterReference(&shooterPed->m_pSeekTarget);
@@ -904,7 +904,7 @@ CWeapon::DoBulletImpact(CEntity *shooter, CEntity *victim,
 							victimPed->bIsStanding = false;
 
 							victimPed->ApplyMoveForce(posOffset.x*-5.0f, posOffset.y*-5.0f, 5.0f);
-							victimPed->SetFall(1500, AnimationId(ANIM_KO_SKID_FRONT + localDir), false);
+							victimPed->SetFall(1500, AnimationId(ANIM_STD_HIGHIMPACT_FRONT + localDir), false);
 
 							victimPed->InflictDamage(shooter, m_eWeaponType, info->m_nDamage, (ePedPieceTypes)point->pieceB, localDir);
 						}
@@ -917,7 +917,7 @@ CWeapon::DoBulletImpact(CEntity *shooter, CEntity *victim,
 								{
 									victimPed->ClearAttackByRemovingAnim();
 
-									CAnimBlendAssociation *asoc = CAnimManager::AddAnimation(victimPed->GetClump(), ASSOCGRP_STD, AnimationId(ANIM_SHOT_FRONT_PARTIAL + localDir));
+									CAnimBlendAssociation *asoc = CAnimManager::AddAnimation(victimPed->GetClump(), ASSOCGRP_STD, AnimationId(ANIM_STD_HITBYGUN_FRONT + localDir));
 									ASSERT(asoc!=nil);
 
 									asoc->blendAmount = 0.0f;
@@ -933,7 +933,7 @@ CWeapon::DoBulletImpact(CEntity *shooter, CEntity *victim,
 							{
 								victimPed->ClearAttackByRemovingAnim();
 
-								CAnimBlendAssociation *asoc = CAnimManager::AddAnimation(victimPed->GetClump(), ASSOCGRP_STD, AnimationId(ANIM_SHOT_FRONT_PARTIAL + localDir));
+								CAnimBlendAssociation *asoc = CAnimManager::AddAnimation(victimPed->GetClump(), ASSOCGRP_STD, AnimationId(ANIM_STD_HITBYGUN_FRONT + localDir));
 								ASSERT(asoc!=nil);
 
 								asoc->blendAmount = 0.0f;
@@ -983,9 +983,9 @@ CWeapon::DoBulletImpact(CEntity *shooter, CEntity *victim,
 					{
 						CAnimBlendAssociation *asoc;
 						if ( RpAnimBlendClumpGetFirstAssociation(victimPed->GetClump(), ASSOC_FRONTAL) )
-							asoc = CAnimManager::BlendAnimation(victimPed->GetClump(), ASSOCGRP_STD, ANIM_FLOOR_HIT_F, 8.0f);
+							asoc = CAnimManager::BlendAnimation(victimPed->GetClump(), ASSOCGRP_STD, ANIM_STD_HIT_FLOOR_FRONT, 8.0f);
 						else
-							asoc = CAnimManager::BlendAnimation(victimPed->GetClump(), ASSOCGRP_STD, ANIM_FLOOR_HIT,   8.0f);
+							asoc = CAnimManager::BlendAnimation(victimPed->GetClump(), ASSOCGRP_STD, ANIM_STD_HIT_FLOOR,   8.0f);
 
 						if ( asoc )
 						{
@@ -1248,7 +1248,7 @@ CWeapon::FireShotgun(CEntity *shooter, CVector *fireSource)
 						victimPed->ApplyMoveForce(posOffset.x*-2.0f, posOffset.y*-2.0f, 0.0f);
 
 					if ( cantStandup )
-						victimPed->SetFall(1500, AnimationId(ANIM_KO_SKID_FRONT + localDir), false);
+						victimPed->SetFall(1500, AnimationId(ANIM_STD_HIGHIMPACT_FRONT + localDir), false);
 
 					victimPed->InflictDamage(shooter, m_eWeaponType, info->m_nDamage, (ePedPieceTypes)point.pieceB, localDir);
 
@@ -1719,7 +1719,7 @@ CWeapon::FireInstantHitFromCar(CAutomobile *shooter, bool left)
 				victimPed->ReactToAttack(FindPlayerPed());
 				victimPed->ClearAttackByRemovingAnim();
 
-				CAnimBlendAssociation *asoc = CAnimManager::AddAnimation(victimPed->GetClump(), ASSOCGRP_STD, AnimationId(ANIM_SHOT_FRONT_PARTIAL + localDir));
+				CAnimBlendAssociation *asoc = CAnimManager::AddAnimation(victimPed->GetClump(), ASSOCGRP_STD, AnimationId(ANIM_STD_HITBYGUN_FRONT + localDir));
 				ASSERT(asoc!=nil);
 				asoc->blendAmount = 0.0f;
 				asoc->blendDelta  = 8.0f;
@@ -2089,7 +2089,7 @@ FireOneInstantHitRound(CVector *source, CVector *target, int32 damage)
 
 				victimPed->ClearAttackByRemovingAnim();
 
-				CAnimBlendAssociation *asoc = CAnimManager::AddAnimation(victimPed->GetClump(), ASSOCGRP_STD, AnimationId(ANIM_SHOT_FRONT_PARTIAL + localDir));
+				CAnimBlendAssociation *asoc = CAnimManager::AddAnimation(victimPed->GetClump(), ASSOCGRP_STD, AnimationId(ANIM_STD_HITBYGUN_FRONT + localDir));
 				ASSERT(asoc!=nil);
 				asoc->blendAmount = 0.0f;
 				asoc->blendDelta  = 8.0f;
diff --git a/src/weapons/WeaponInfo.cpp b/src/weapons/WeaponInfo.cpp
index 10737acb..ba872454 100644
--- a/src/weapons/WeaponInfo.cpp
+++ b/src/weapons/WeaponInfo.cpp
@@ -37,8 +37,8 @@ CWeaponInfo::Initialise(void)
 	debug("Initialising CWeaponInfo...\n");
 	for (int i = 0; i < WEAPONTYPE_TOTALWEAPONS; i++) {
 		aWeaponInfo[i].m_eWeaponFire = WEAPON_FIRE_INSTANT_HIT;
-		aWeaponInfo[i].m_AnimToPlay = ANIM_PUNCH_R;
-		aWeaponInfo[i].m_Anim2ToPlay = NUM_ANIMS;
+		aWeaponInfo[i].m_AnimToPlay = ANIM_STD_PUNCH;
+		aWeaponInfo[i].m_Anim2ToPlay = ANIM_STD_NUM;
 		aWeaponInfo[i].m_Flags = WEAPONFLAG_USE_GRAVITY | WEAPONFLAG_SLOWS_DOWN | WEAPONFLAG_RAND_SPEED | WEAPONFLAG_EXPANDS | WEAPONFLAG_EXPLODES;
 	}
 	debug("Loading weapon data...\n");
@@ -96,7 +96,7 @@ CWeaponInfo::LoadWeaponData(void)
 		fireType[0] = '\0';
 		fireOffsetY = 0.0f;
 		fireOffsetZ = 0.0f;
-		animId = ANIM_WALK;
+		animId = ANIM_STD_WALK;
 		sscanf(
 			&line[lp],
 			"%s %s %f %d %d %d %d %f %f %f %f %f %f %f %s %s %f %f %f %f %d %d",