API tools faq
paste
XADRENALINEIX

HuN's Ped Riot Generator 2.0 BETA

XADRENALINEIX
Jul 6th, 2013
729
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 10.66 KB | None | 0 0
raw download clone embed print report
  1. #include <natives.h>
  2. #include <common.h>
  3. #include <strings.h>
  4. #include <types.h>
  5. #include <consts.h>
  6.  
  7. Ped riot[30];
  8. Blip rp[30];
  9. int dm;
  10. int cdm;
  11. uint rmodel[2];
  12. uint weapon[13];
  13. uint stat = 0;
  14. uint mlvl = 0;
  15. uint rgen = 0;
  16. float xp, yp, zp;
  17.  
  18. //############### Define Ps3 GamePad ################################//
  19. #define DPAD_DOWN  0x9
  20. #define CIRCLE  0x11
  21. //############### Define Ps3 GamePad ################################//
  22.  
  23. bool IsKeyPressed(uint iKey , uint iJey)
  24. {
  25.     return IS_BUTTON_PRESSED(0,iKey) && IS_BUTTON_JUST_PRESSED(0,iJey);
  26. }
  27.  
  28. void Print(char *string)
  29. {
  30.     PRINT_STRING_WITH_LITERAL_STRING_NOW("STRING", string, 4500, 1);
  31. }
  32.  
  33. void InitRiotSet(void)
  34. {
  35.     uint episode = GET_CURRENT_EPISODE();
  36.     float cx, cy, cz;
  37.     rmodel[0] = MODEL_M_Y_MULTIPLAYER;
  38.     rmodel[1] = MODEL_F_Y_MULTIPLAYER;
  39.     if(episode != 1 && episode != 2){
  40.         weapon[0] = WEAPON_PISTOL;
  41.         weapon[1] = WEAPON_MICRO_UZI;
  42.         weapon[2] = WEAPON_MP5;
  43.         weapon[3] = WEAPON_SHOTGUN;
  44.         weapon[4] = WEAPON_BARETTA;
  45.         weapon[5] = WEAPON_AK47;
  46.         weapon[6] = WEAPON_M4;
  47.         weapon[7] = WEAPON_SNIPERRIFLE;
  48.         weapon[8] = WEAPON_MOLOTOV;
  49.         weapon[9] = WEAPON_GRENADE;
  50.         weapon[10] = WEAPON_BASEBALLBAT;
  51.         weapon[11] = WEAPON_KNIFE;
  52.         weapon[12] = WEAPON_RLAUNCHER;
  53.     }
  54.     if(episode == 1){
  55.         weapon[0] = WEAPON_MICRO_UZI;
  56.         weapon[1] = WEAPON_MP5;
  57.         weapon[2] = WEAPON_AK47;
  58.         weapon[3] = WEAPON_M40A1;
  59.         weapon[4] = WEAPON_MOLOTOV;
  60.         weapon[5] = WEAPON_BASEBALLBAT;
  61.         weapon[6] = WEAPON_KNIFE;
  62.         weapon[7] = WEAPON_EPISODIC_1;
  63.         weapon[8] = WEAPON_EPISODIC_2;
  64.         weapon[9] = WEAPON_EPISODIC_4;
  65.         weapon[10] = WEAPON_EPISODIC_6;
  66.         weapon[11] = WEAPON_EPISODIC_7;
  67.         weapon[12] = WEAPON_EPISODIC_8;
  68.     }
  69.     if(episode == 2){
  70.         weapon[0] = WEAPON_MP5;
  71.         weapon[1] = WEAPON_AK47;
  72.         weapon[2] = WEAPON_MOLOTOV;
  73.         weapon[3] = WEAPON_GRENADE;
  74.         weapon[4] = WEAPON_BASEBALLBAT;
  75.         weapon[5] = WEAPON_KNIFE;
  76.         weapon[6] = WEAPON_EPISODIC_9;
  77.         weapon[7] = WEAPON_EPISODIC_10;
  78.         weapon[8] = WEAPON_EPISODIC_11;
  79.         weapon[9] = WEAPON_EPISODIC_12;
  80.         weapon[10] = WEAPON_EPISODIC_13;
  81.         weapon[11] = WEAPON_EPISODIC_14;
  82.         weapon[12] = WEAPON_EPISODIC_15;
  83.     }
  84.     GET_MAX_WANTED_LEVEL(&mlvl);
  85.     GET_CHAR_COORDINATES(GetPlayerPed(), &cx, &cy, &cz);
  86.     LOAD_CHAR_DECISION_MAKER(2, &dm);
  87.     LOAD_COMBAT_DECISION_MAKER(3, &cdm);
  88.     SET_DECISION_MAKER_ATTRIBUTE_SIGHT_RANGE(dm, 250);
  89.     SET_DECISION_MAKER_ATTRIBUTE_SIGHT_RANGE(cdm, 250);
  90.     CLEAR_AREA_OF_CARS(cx, cy, cz, 250.0);
  91.     CLEAR_AREA_OF_CHARS(cx, cy, cz, 250.0);
  92.     SET_CAR_DENSITY_MULTIPLIER(0.5);
  93.     SET_RANDOM_CAR_DENSITY_MULTIPLIER(0.5);
  94.     SET_PARKED_CAR_DENSITY_MULTIPLIER(0.5);
  95.     SET_ALL_RANDOM_PEDS_FLEE(GetPlayerIndex(), TRUE);
  96.     SWITCH_RANDOM_BOATS(FALSE);
  97.     SWITCH_POLICE_HELIS(FALSE);
  98.     SWITCH_AMBIENT_PLANES(FALSE);
  99.     SWITCH_GARBAGE_TRUCKS(FALSE);
  100.     SWITCH_RANDOM_TRAINS(FALSE);
  101.     SET_DEAD_PEDS_DROP_WEAPONS(FALSE);
  102. }
  103.  
  104. void RiotVar(uint ptype)
  105. {
  106.     uint episode = GET_CURRENT_EPISODE();
  107.     uint comp, var;
  108.     if(episode != 1 && episode != 2){
  109.         GENERATE_RANDOM_INT_IN_RANGE(0, 10, &comp);
  110.         GENERATE_RANDOM_INT_IN_RANGE(0, 5, &var);
  111.         SET_CHAR_PROP_INDEX_TEXTURE(ptype, 0, comp, var);
  112.         GENERATE_RANDOM_INT_IN_RANGE(0, 10, &comp);
  113.         GENERATE_RANDOM_INT_IN_RANGE(0, 2, &var);
  114.         SET_CHAR_PROP_INDEX_TEXTURE(ptype, 1, comp, var);
  115.         GENERATE_RANDOM_INT_IN_RANGE(0, 4, &comp);
  116.         GENERATE_RANDOM_INT_IN_RANGE(0, 3, &var);
  117.         SET_CHAR_COMPONENT_VARIATION(ptype, 1, comp, var);
  118.         GENERATE_RANDOM_INT_IN_RANGE(0, 3, &comp);
  119.         GENERATE_RANDOM_INT_IN_RANGE(0, 3, &var);
  120.         SET_CHAR_COMPONENT_VARIATION(ptype, 2, comp, var);
  121.         if(IS_CHAR_MALE(ptype))
  122.         {
  123.             GENERATE_RANDOM_INT_IN_RANGE(0, 4, &comp);
  124.             GENERATE_RANDOM_INT_IN_RANGE(0, 3, &var);
  125.             SET_CHAR_COMPONENT_VARIATION(ptype, 0, comp, var);
  126.         }
  127.         else if(!IS_CHAR_MALE(ptype))
  128.         {
  129.             GENERATE_RANDOM_INT_IN_RANGE(0, 4, &comp);
  130.             GENERATE_RANDOM_INT_IN_RANGE(0, 2, &var);
  131.             SET_CHAR_COMPONENT_VARIATION(ptype, 0, comp, var);
  132.             GENERATE_RANDOM_INT_IN_RANGE(0, 4, &comp);
  133.             GENERATE_RANDOM_INT_IN_RANGE(0, 3, &var);
  134.             SET_CHAR_COMPONENT_VARIATION(ptype, 7, comp, var);
  135.         }
  136.     }
  137.     if(episode == 1){
  138.         SET_CHAR_RANDOM_COMPONENT_VARIATION(ptype);
  139.         GENERATE_RANDOM_INT_IN_RANGE(0, 6, &comp);
  140.         GENERATE_RANDOM_INT_IN_RANGE(0, 3, &var);
  141.         SET_CHAR_PROP_INDEX_TEXTURE(ptype, 0, comp, var);
  142.         GENERATE_RANDOM_INT_IN_RANGE(0, 6, &comp);
  143.         GENERATE_RANDOM_INT_IN_RANGE(0, 2, &var);
  144.         SET_CHAR_PROP_INDEX_TEXTURE(ptype, 1, comp, var);
  145.         SET_CHAR_COMPONENT_VARIATION(ptype, 4, 0, var);
  146.         if(IS_CHAR_MALE(ptype))
  147.         {
  148.             GENERATE_RANDOM_INT_IN_RANGE(0, 3, &comp);
  149.             GENERATE_RANDOM_INT_IN_RANGE(0, 3, &var);
  150.             if(comp == 0)
  151.             {
  152.                 SET_CHAR_COMPONENT_VARIATION(ptype, 1, 0, var);
  153.             }
  154.             else if(comp == 1)
  155.             {
  156.                 SET_CHAR_COMPONENT_VARIATION(ptype, 1, 2, var);
  157.             }
  158.             else if(comp == 2)
  159.             {
  160.                 SET_CHAR_COMPONENT_VARIATION(ptype, 1, 3, var);
  161.             }
  162.         }
  163.         else if(!IS_CHAR_MALE(ptype))
  164.         {
  165.             GENERATE_RANDOM_INT_IN_RANGE(0, 2, &comp);
  166.             GENERATE_RANDOM_INT_IN_RANGE(0, 3, &var);
  167.             if(comp == 0)
  168.             {
  169.                 SET_CHAR_COMPONENT_VARIATION(ptype, 1, 0, var);
  170.             }
  171.             else if(comp == 1)
  172.             {
  173.                 SET_CHAR_COMPONENT_VARIATION(ptype, 1, 2, var);
  174.             }
  175.         }
  176.     }
  177.     if(episode == 2){
  178.         SET_CHAR_RANDOM_COMPONENT_VARIATION(ptype);
  179.         GENERATE_RANDOM_INT_IN_RANGE(0, 8, &comp);
  180.         GENERATE_RANDOM_INT_IN_RANGE(0, 2, &var);
  181.         SET_CHAR_PROP_INDEX_TEXTURE(ptype, 1, comp, var);
  182.         if(IS_CHAR_MALE(ptype))
  183.         {
  184.             GENERATE_RANDOM_INT_IN_RANGE(0, 8, &comp);
  185.             GENERATE_RANDOM_INT_IN_RANGE(0, 5, &var);
  186.             SET_CHAR_PROP_INDEX_TEXTURE(ptype, 0, comp, var);
  187.         }
  188.     }
  189. }
  190.  
  191. void RiotRel(uint ptype)
  192. {
  193.     uint rel;
  194.     GENERATE_RANDOM_INT_IN_RANGE(23, 26, &rel);
  195.     SET_CHAR_RELATIONSHIP_GROUP(ptype, rel);
  196.     SET_CHAR_RELATIONSHIP(ptype, 0, rel);
  197.     SET_CHAR_RELATIONSHIP(ptype, 4, 0);
  198.     SET_CHAR_RELATIONSHIP(ptype, 5, 1);
  199.     SET_CHAR_RELATIONSHIP(ptype, 5, 2);
  200.     SET_CHAR_RELATIONSHIP(ptype, 5, 3);
  201.     SET_CHAR_RELATIONSHIP(ptype, 5, 4);
  202.     SET_CHAR_RELATIONSHIP(ptype, 5, 5);
  203.     SET_CHAR_RELATIONSHIP(ptype, 5, 6);
  204.     SET_CHAR_RELATIONSHIP(ptype, 5, 7);
  205.     SET_CHAR_RELATIONSHIP(ptype, 5, 8);
  206.     SET_CHAR_RELATIONSHIP(ptype, 5, 9);
  207.     SET_CHAR_RELATIONSHIP(ptype, 5, 10);
  208.     SET_CHAR_RELATIONSHIP(ptype, 5, 11);
  209.     SET_CHAR_RELATIONSHIP(ptype, 5, 12);
  210.     SET_CHAR_RELATIONSHIP(ptype, 5, 13);
  211.     SET_CHAR_RELATIONSHIP(ptype, 5, 14);
  212.     SET_CHAR_RELATIONSHIP(ptype, 5, 15);
  213.     SET_CHAR_RELATIONSHIP(ptype, 5, 16);
  214.     SET_CHAR_RELATIONSHIP(ptype, 5, 17);
  215.     SET_CHAR_RELATIONSHIP(ptype, 5, 18);
  216.     SET_CHAR_RELATIONSHIP(ptype, 5, 19);
  217.     SET_CHAR_RELATIONSHIP(ptype, 5, 20);
  218.     SET_CHAR_RELATIONSHIP(ptype, 5, 21);
  219.     SET_CHAR_RELATIONSHIP(ptype, 5, 22);
  220.     if(rel == 23)
  221.     {
  222.         SET_CHAR_RELATIONSHIP(ptype, 5, 24);
  223.         SET_CHAR_RELATIONSHIP(ptype, 5, 25);
  224.     }
  225.     else if(rel == 24)
  226.     {
  227.         SET_CHAR_RELATIONSHIP(ptype, 5, 23);
  228.         SET_CHAR_RELATIONSHIP(ptype, 5, 25);
  229.     }
  230.     else if(rel == 25)
  231.     {
  232.         SET_CHAR_RELATIONSHIP(ptype, 5, 23);
  233.         SET_CHAR_RELATIONSHIP(ptype, 5, 24);
  234.     }
  235. }
  236.  
  237. void RiotSet(uint ptype)
  238. {
  239.     SET_CHAR_MONEY(ptype, 0);
  240.     SET_CHAR_DECISION_MAKER(ptype, dm);
  241.     SET_COMBAT_DECISION_MAKER(ptype, cdm);
  242.     SET_SENSE_RANGE(ptype, 500.0);
  243.     SET_CHAR_KEEP_TASK(ptype, TRUE);
  244.     TASK_COMBAT_HATED_TARGETS_AROUND_CHAR(ptype, 500.0);
  245.     SET_CHAR_WILL_MOVE_WHEN_INJURED(ptype, TRUE);
  246.     SET_CHAR_WILL_USE_COVER(ptype, TRUE);
  247.     SET_CHAR_WILL_USE_CARS_IN_COMBAT(ptype, TRUE);
  248.     SET_CHAR_WILL_DO_DRIVEBYS(ptype, TRUE);
  249.     SET_PED_DONT_DO_EVASIVE_DIVES(ptype, TRUE);
  250.     SET_PED_DIES_WHEN_INJURED(ptype, TRUE);
  251.     SET_PED_GENERATES_DEAD_BODY_EVENTS(ptype, TRUE);
  252.     SET_PED_PATH_MAY_USE_CLIMBOVERS(ptype, TRUE);
  253.     SET_PED_PATH_MAY_DROP_FROM_HEIGHT(ptype, TRUE);
  254.     SET_PED_PATH_MAY_USE_LADDERS(ptype, TRUE);
  255. }
  256.  
  257. void RiotWep(uint ptype)
  258. {
  259.     uint wep;
  260.     GENERATE_RANDOM_INT_IN_RANGE(0, 13, &wep);
  261.     GIVE_WEAPON_TO_CHAR(ptype, weapon[wep], AMMO_MAX, FALSE);
  262.     SET_CURRENT_CHAR_WEAPON(ptype, weapon[wep], TRUE);
  263. }
  264.  
  265. void Pset(void)
  266. {
  267.     if(IS_PLAYER_PLAYING(GetPlayerIndex()))
  268.     {
  269.         GET_CHAR_COORDINATES(GetPlayerPed(), &xp, &yp, &zp);
  270.         CLEAR_WANTED_LEVEL(GetPlayerIndex());
  271.         SET_MAX_WANTED_LEVEL(0);
  272.         SET_CHAR_WANTED_BY_POLICE(GetPlayerPed(), FALSE);
  273.         SET_POLICE_RADAR_BLIPS(FALSE);
  274.         if(rgen == 1)
  275.         {
  276.             WAIT(5000);
  277.             rgen = 0;
  278.         }
  279.     }
  280.     else if(IS_CHAR_DEAD(GetPlayerPed()))
  281.     {
  282.         rgen = 1;
  283.     }
  284. }
  285.  
  286. void RiotGen(void)
  287. {
  288.     uint I;
  289.     for (I = 0; I <= 29; I++)
  290.     {
  291.         if(DOES_CHAR_EXIST(riot[I]))
  292.         {  
  293.             float zx, zy, zz;
  294.             float distb;
  295.             GET_CHAR_COORDINATES(riot[I], &zx, &zy, &zz);
  296.             GET_DISTANCE_BETWEEN_COORDS_3D(xp, yp, zp, zx, zy, zz, &distb);
  297.             if(IS_CHAR_DEAD(riot[I]) || IS_CHAR_DEAD(GetPlayerPed()) || distb > 120.0)
  298.             {
  299.                 EXPLODE_CHAR_HEAD(riot[I]);
  300.                 TASK_DIE(riot[I]);
  301.                 REMOVE_BLIP(rp[I]);
  302.                 MARK_CHAR_AS_NO_LONGER_NEEDED(&riot[I]);
  303.             }
  304.         }
  305.         else if(!DOES_CHAR_EXIST(riot[I]))
  306.         {
  307.             if(IS_PLAYER_PLAYING(GetPlayerIndex()))
  308.             {
  309.                 if(rgen == 0)
  310.                 {
  311.                     float offx;
  312.                     float offy;
  313.                     float x, y, z;
  314.                     float zgrnd;
  315.                     float sx, sy, sz;
  316.                     float dista;
  317.                     GENERATE_RANDOM_FLOAT_IN_RANGE(-100.0, 100.0, &offx);
  318.                     GENERATE_RANDOM_FLOAT_IN_RANGE(-100.0, 100.0, &offy);
  319.                     GET_OFFSET_FROM_CHAR_IN_WORLD_COORDS(GetPlayerPed(), offx, offy, 0, &x, &y, &z);
  320.                     GET_GROUND_Z_FOR_3D_COORD(x, y, z, &zgrnd);
  321.                     GET_SAFE_POSITION_FOR_CHAR(x, y, zgrnd, TRUE, &sx, &sy, &sz);
  322.                     GET_DISTANCE_BETWEEN_COORDS_3D(xp, yp, zp, sx, sy, sz, &dista);
  323.                     if(dista >= 35.0)
  324.                     {
  325.                         if(dista <= 100.0)
  326.                         {
  327.                             uint rm;
  328.                             CLEAR_AREA_OF_CARS(sx, sy, sz, 3.0);
  329.                             CLEAR_AREA_OF_CHARS(sx, sy, sz, 3.0);
  330.                             GENERATE_RANDOM_INT_IN_RANGE(0, 2, &rm);
  331.                             REQUEST_MODEL(rmodel[rm]);
  332.                             while (!HAS_MODEL_LOADED(rmodel[rm])) WAIT(0);
  333.                             CREATE_CHAR(16, rmodel[rm], sx, sy, sz, &riot[I], true);
  334.                             MARK_MODEL_AS_NO_LONGER_NEEDED(rmodel[rm]);
  335.                             ADD_BLIP_FOR_CHAR(riot[I], &rp[I]);
  336.                             CHANGE_BLIP_COLOUR(rp[I], I);
  337.                             CHANGE_BLIP_NAME_FROM_ASCII(rp[I], "Riot Ped");
  338.                             RiotSet(riot[I]);
  339.                             RiotVar(riot[I]);
  340.                             RiotWep(riot[I]);
  341.                             RiotRel(riot[I]);
  342.                             WAIT(50);
  343.                         }
  344.                     }  
  345.                 }  
  346.             }
  347.         }  
  348.     }
  349. }
  350.  
  351. void DisableRgen(void)
  352.  {
  353.     if(IsKeyPressed(DPAD_DOWN,CIRCLE))
  354.     {
  355.         Print("Riot Generator Disabled");
  356.         SET_MAX_WANTED_LEVEL(mlvl);
  357.         SET_CAR_DENSITY_MULTIPLIER(1.25);
  358.         SET_RANDOM_CAR_DENSITY_MULTIPLIER(1.25);
  359.         SET_PARKED_CAR_DENSITY_MULTIPLIER(2.25);
  360.         SET_ALL_RANDOM_PEDS_FLEE(GetPlayerIndex(), FALSE);
  361.         SWITCH_RANDOM_BOATS(TRUE);
  362.         SWITCH_POLICE_HELIS(TRUE);
  363.         SWITCH_AMBIENT_PLANES(TRUE);
  364.         SWITCH_GARBAGE_TRUCKS(TRUE);
  365.         SWITCH_RANDOM_TRAINS(TRUE);
  366.         SET_POLICE_RADAR_BLIPS(TRUE);
  367.         SET_DEAD_PEDS_DROP_WEAPONS(TRUE);
  368.         TERMINATE_THIS_SCRIPT();
  369.     }
  370. }
  371.  
  372. void main(void)
  373. {  
  374.     InitRiotSet();
  375.     while (TRUE)
  376.     {
  377.         WAIT(0);
  378.         Pset();
  379.         RiotGen();
  380.         DisableRgen();
  381.     }
  382. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!