home *** CD-ROM | disk | FTP | other *** search
/ Chip 2011 November / CHIP_2011_11.iso / Programy / Inne / Gry / OpenArena / missionpack / mp-pak0.pk3 / botfiles / fuzi.c < prev    next >
Encoding:
C/C++ Source or Header  |  2007-09-04  |  11.8 KB  |  679 lines
  1. /*
  2. ===========================================================================
  3. Copyright (C) 2006 Dmn_clown (aka: Bob Isaac (rjisaac@gmail.com))
  4.  
  5. This file is part of Open Arena and is based upon Mr. Elusive's fuzzy logic
  6. system found in Quake 3 Arena.
  7.  
  8. Open Arena is free software; you can redistribute it
  9. and/or modify it under the terms of the GNU General Public License as
  10. published by the Free Software Foundation; either version 2 of the License,
  11. or (at your option) any later version.
  12.  
  13. Open Arena is distributed in the hope that it will be
  14. useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16. GNU General Public License for more details.
  17.  
  18. You should have received a copy of the GNU General Public License
  19. along with Foobar; if not, write to the Free Software
  20. Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  21. ===========================================================================
  22. */
  23.  
  24.  
  25. #define ARMOR                20
  26. #define AMMO                20
  27. #define HEALTH                20
  28. #define POWERUP                20
  29. #define WEAPON                20
  30.  
  31. //breaks compatibility with the existing q3a bots, sorry.
  32. #define FP(x)    (x < 0 ? 1 : x)
  33. #define ARS(x)     balance($evalfloat(FP(FPA/x)), $evalfloat(FP(FPA/x-ARMOR)), $evalfloat(FP(FPA/x+ARMOR)))
  34. #define AS(x)    balance($evalfloat(FP(x)), $evalfloat(FP(x/AMMO)), $evalfloat(FP(x*AMMO)))
  35. #define HS(x)    balance($evalfloat(FP(FPH/x)), $evalfloat(FP(FPH/x-HEALTH)), $evalfloat(FP(FPH/x+HEALTH)))
  36. #define PS(x)    balance($evalfloat(FP(x)), $evalfloat(FP(x/POWERUP)), $evalfloat(FP(x*POWERUP)))
  37. #define WS(x)    balance($evalfloat(FP(x)), $evalfloat(FP(x/WEAPON)), $evalfloat(FP(x*WEAPON)))
  38.  
  39.  
  40. weight "item_armor_shard"
  41. {
  42. switch(INVENTORY_SCOUT)
  43.     {
  44.     case 1:
  45.     {
  46.     switch(INVENTORY_ARMOR)
  47.     {
  48.     case 10: return ARS(20);
  49.     case 20: return ARS(20);
  50.     case 30: return ARS(20);
  51.     case 40: return ARS(19);
  52.     case 50: return ARS(19);
  53.     case 60: return ARS(19);
  54.     case 70: return ARS(19);
  55.     case 80: return ARS(18);
  56.     case 90: return ARS(18);
  57.     case 100: return ARS(15);
  58.     case 110: return ARS(15);
  59.     case 120: return ARS(15);
  60.     case 130: return ARS(15);
  61.     case 140: return ARS(12);
  62.     case 150: return ARS(12);
  63.     case 160: return ARS(12);
  64.     case 170: return ARS(12);
  65.     case 180: return ARS(12);
  66.     case 190: return ARS(11);
  67.     case 200: return ARS(11);
  68.     default: return ARS(1);
  69.     } 
  70.     } 
  71.     default: return 0;
  72.     } 
  73. }
  74.  
  75. weight "item_armor_combat"
  76. {
  77.     switch(INVENTORY_SCOUT) 
  78.     {
  79.     case 1:
  80.     {
  81.     switch(INVENTORY_ARMOR)
  82.     {
  83.     case 10: return ARS(80);
  84.     case 20: return ARS(70);
  85.     case 30: return ARS(65);
  86.     case 40: return ARS(65);
  87.     case 50: return ARS(65);
  88.     case 60: return ARS(60);
  89.     case 70: return ARS(60);
  90.     case 80: return ARS(40);
  91.     case 90: return ARS(40);
  92.     case 100: return ARS(40);
  93.     case 110: return ARS(30);
  94.     case 120: return ARS(30);
  95.     case 130: return ARS(30);
  96.     case 140: return ARS(25);
  97.     case 150: return ARS(25);
  98.     case 160: return ARS(25);
  99.     case 170: return ARS(25);
  100.     case 180: return ARS(20);
  101.     case 190: return ARS(20);
  102.     case 200: return ARS(20);
  103.     default: return ARS(1);
  104.     }
  105.     }
  106.     default: return 0;
  107.     } 
  108. }
  109.  
  110. weight "item_armor_body"
  111. {
  112.     switch(INVENTORY_SCOUT) 
  113.     {
  114.     case 1:
  115.     {
  116.     switch(INVENTORY_ARMOR)
  117.     {
  118.     case 10: return ARS(100);
  119.     case 20: return ARS(95);
  120.     case 30: return ARS(95);
  121.     case 40: return ARS(95);
  122.     case 50: return ARS(90);
  123.     case 60: return ARS(60);
  124.     case 70: return ARS(60);
  125.     case 80: return ARS(55);
  126.     case 90: return ARS(55);
  127.     case 100: return ARS(50);
  128.     case 110: return ARS(40);
  129.     case 120: return ARS(40);
  130.     case 130: return ARS(35);
  131.     case 140: return ARS(25);
  132.     case 150: return ARS(15);
  133.     case 160: return ARS(15);
  134.     case 170: return ARS(15);
  135.     case 180: return ARS(10);
  136.     case 190: return ARS(10);
  137.     case 200: return ARS(10);
  138.     default: return ARS(1);
  139.     }
  140.     }
  141.     default: return 0;
  142.     } 
  143. }
  144.  
  145. weight "item_health_small"
  146. {
  147.     switch(INVENTORY_HEALTH)
  148.     {
  149.     case 10: return HS(100);
  150.     case 20: return HS(90);
  151.     case 30: return HS(85);
  152.     case 40: return HS(80);
  153.     case 50: return HS(75);
  154.     case 60: return HS(70);
  155.     case 70: return HS(65);
  156.     case 80: return HS(60);
  157.     case 90: return HS(55);
  158.     case 100: return HS(50);
  159.     default: return 0;
  160.     }
  161. }
  162.  
  163. weight "item_health"
  164. {
  165.     switch(INVENTORY_HEALTH)
  166.     {
  167.     case 10: return HS(110);
  168.     case 20: return HS(100);
  169.     case 30: return HS(90);
  170.     case 40: return HS(80);
  171.     case 50: return HS(70);
  172.     case 60: return HS(60);
  173.     case 70: return HS(50);
  174.     case 80: return HS(40);
  175.     case 90: return HS(30);
  176.     case 100: return HS(30);
  177.     default: return 0;
  178.     }
  179. } 
  180.  
  181. weight "item_health_large"
  182. {
  183.     
  184.     switch(INVENTORY_HEALTH)
  185.     {
  186.     case 10: return HS(120);
  187.     case 20: return HS(110);
  188.     case 30: return HS(100);
  189.     case 40: return HS(90);
  190.     case 50: return HS(80);
  191.     case 60: return HS(70);
  192.     case 70: return HS(60);
  193.     case 80: return HS(50);
  194.     case 90: return HS(40);
  195.     case 100: return HS(30);
  196.     default: return 0;
  197.     }
  198. }
  199.  
  200. weight "item_health_mega"
  201. {
  202.     switch(INVENTORY_HEALTH)
  203.     {
  204.     case 10: return HS(150);
  205.     case 20: return HS(120);
  206.     case 30: return HS(110);
  207.     case 40: return HS(100);
  208.     case 50: return HS(90);
  209.     case 60: return HS(90);
  210.     case 70: return HS(80);
  211.     case 80: return HS(80);
  212.     case 90: return HS(70);
  213.     case 100: return HS(60);
  214.     default: return 0;
  215.     }
  216. }
  217.  
  218. weight "weapon_shotgun"
  219. {
  220.     switch(INVENTORY_SHOTGUN)
  221.     {
  222.     case 1: return WS(SGW);
  223.     default: return 1;
  224.     }
  225. }
  226.  
  227. weight "weapon_machinegun"
  228. {
  229.     switch(INVENTORY_MACHINEGUN)
  230.     {
  231.     case 1: return WS(MGW);
  232.     default: return 1;
  233.     } 
  234. }
  235.  
  236. weight "weapon_grenadelauncher"
  237. {
  238.     switch(INVENTORY_GRENADELAUNCHER)
  239.     {
  240.     case 1: return WS(GLW);
  241.     default: return 1;
  242.     } 
  243. }
  244.  
  245. weight "weapon_rocketlauncher"
  246. {
  247.     switch(INVENTORY_ROCKETLAUNCHER)
  248.     {
  249.     case 1: return WS(RLW);
  250.     default: return 1;
  251.     } 
  252. }
  253.  
  254. weight "weapon_lightning"
  255. {
  256.     switch(INVENTORY_LIGHTNING)
  257.     {
  258.     case 1: return WS(LGW);
  259.     default: return 1;
  260.     }
  261. } 
  262.  
  263. weight "weapon_railgun"
  264. {
  265.     switch(INVENTORY_RAILGUN)
  266.     {
  267.     case 1: return WS(RGW);
  268.     default: return 1;
  269.     } 
  270. }
  271.  
  272. weight "weapon_plasmagun"
  273. {
  274.     switch(INVENTORY_PLASMAGUN)
  275.     {
  276.     case 1: return WS(PGW);
  277.     default: return 1;
  278.     } 
  279. }
  280.  
  281. weight "weapon_bfg"
  282. {
  283.     switch(INVENTORY_BFG10K)
  284.     {
  285.     case 1: return WS(BFW);
  286.     default: return 1;
  287.     } 
  288. }
  289.  
  290. weight "weapon_nailgun"
  291. {
  292.     switch(INVENTORY_NAILGUN)
  293.     {
  294.     case 1: return WS(NGW);
  295.     default: return 1;
  296.     } 
  297. }
  298.  
  299. weight "weapon_prox_launcher"
  300. {
  301.     switch(INVENTORY_PROXLAUNCHER)
  302.     {
  303.     case 1: return WS(PXW);
  304.     default: return 1;
  305.     }
  306. }
  307.  
  308. weight "weapon_chaingun"
  309. {
  310.     switch(INVENTORY_CHAINGUN)
  311.     {
  312.     case 1: return WS(CGW);
  313.     default: return 1;
  314.     } 
  315. }
  316.  
  317.  
  318. weight "ammo_shells"
  319. {
  320.     switch(INVENTORY_SHELLS)
  321.     {
  322.     case 20: return AS(30);
  323.     case 40: return AS(30);
  324.     case 60: return AS(11);
  325.     case 80: return AS(11);
  326.     case 100: return AS(11);
  327.     case 120: return AS(11);
  328.     case 140: return AS(11);
  329.     case 160: return AS(11);
  330.     case 180: return AS(11);
  331.     case 200: return AS(11);
  332.     default: return 0;
  333.     } 
  334. } 
  335.  
  336. weight "ammo_bullets"
  337. {
  338.     switch(INVENTORY_BULLETS)
  339.     {
  340.     case 20: return AS(30);
  341.     case 40: return AS(30);
  342.     case 60: return AS(30);
  343.     case 80: return AS(11);
  344.     case 100: return AS(11);
  345.     case 120: return AS(11);
  346.     case 140: return AS(11);
  347.     case 160: return AS(11);
  348.     case 180: return AS(11);
  349.     case 200: return AS(11);
  350.     default: return 0;
  351.     } 
  352. } 
  353.  
  354. weight "ammo_grenades"
  355. {
  356.     switch(INVENTORY_GRENADES)
  357.     {
  358.     case 20: return AS(30);
  359.     case 40: return AS(30);
  360.     case 60: return AS(11);
  361.     case 80: return AS(11);
  362.     case 100: return AS(11);
  363.     case 120: return AS(11);
  364.     case 140: return AS(11);
  365.     case 160: return AS(11);
  366.     case 180: return AS(11);
  367.     case 200: return AS(11);
  368.     default: return 0;
  369.     } 
  370. } 
  371.  
  372. weight "ammo_cells"
  373. {
  374.     switch(INVENTORY_CELLS)
  375.     {
  376.     case 20: return AS(30);
  377.     case 40: return AS(30);
  378.     case 60: return AS(30);
  379.     case 80: return AS(30);
  380.     case 100: return AS(11);
  381.     case 120: return AS(11);
  382.     case 140: return AS(11);
  383.     case 160: return AS(11);
  384.     case 180: return AS(11);
  385.     case 200: return AS(11);
  386.     default: return 0;
  387.     } 
  388. } 
  389.  
  390. weight "ammo_lightning"
  391. {
  392.     switch(INVENTORY_LIGHTNINGAMMO)
  393.     {
  394.     case 20: return AS(30);
  395.     case 40: return AS(30);
  396.     case 60: return AS(30);
  397.     case 80: return AS(30);
  398.     case 100: return AS(11);
  399.     case 120: return AS(11);
  400.     case 140: return AS(11);
  401.     case 160: return AS(11);
  402.     case 180: return AS(11);
  403.     case 200: return AS(11);
  404.     default: return 0;
  405.     } 
  406. } 
  407.  
  408. weight "ammo_rockets"
  409. {
  410.     switch(INVENTORY_ROCKETS)
  411.     {
  412.     case 20: return AS(30);
  413.     case 40: return AS(30);
  414.     case 60: return AS(11);
  415.     case 80: return AS(11);
  416.     case 100: return AS(11);
  417.     case 120: return AS(11);
  418.     case 140: return AS(11);
  419.     case 160: return AS(11);
  420.     case 180: return AS(11);
  421.     case 200: return AS(11);
  422.     default: return 0;
  423.     } 
  424. } 
  425.  
  426. weight "ammo_slugs"
  427. {
  428.     switch(INVENTORY_SLUGS)
  429.     {
  430.     case 20: return AS(30);
  431.     case 40: return AS(30);
  432.     case 60: return AS(11);
  433.     case 80: return AS(11);
  434.     case 100: return AS(11);
  435.     case 120: return AS(11);
  436.     case 140: return AS(11);
  437.     case 160: return AS(11);
  438.     case 180: return AS(11);
  439.     case 200: return AS(11);
  440.     default: return 0;
  441.     } 
  442. } 
  443.  
  444. weight "ammo_bfg"
  445. {
  446.     switch(INVENTORY_BFGAMMO)
  447.     {
  448.     case 20: return AS(30);
  449.     case 40: return AS(30);
  450.     case 60: return AS(11);
  451.     case 80: return AS(11);
  452.     case 100: return AS(11);
  453.     case 120: return AS(11);
  454.     case 140: return AS(11);
  455.     case 160: return AS(11);
  456.     case 180: return AS(11);
  457.     case 200: return AS(11);
  458.     default: return 0;
  459.     }
  460. } 
  461.  
  462.  
  463. weight "ammo_nails"
  464. {
  465.     switch(INVENTORY_NAILS)
  466.     {
  467.     case 20: return AS(30);
  468.     case 40: return AS(30);
  469.     case 60: return AS(11);
  470.     case 80: return AS(11);
  471.     case 100: return AS(11);
  472.     case 120: return AS(11);
  473.     case 140: return AS(11);
  474.     case 160: return AS(11);
  475.     case 180: return AS(11);
  476.     case 200: return AS(11);
  477.     default: return 0;
  478.     } 
  479. }
  480.  
  481. weight "ammo_mines"
  482. {
  483.     switch(INVENTORY_MINES)
  484.     {
  485.     case 20: return AS(30);
  486.     case 40: return AS(11);
  487.     case 60: return AS(11);
  488.     case 80: return AS(11);
  489.     case 100: return AS(11);
  490.     case 120: return AS(11);
  491.     case 140: return AS(11);
  492.     case 160: return AS(11);
  493.     case 180: return AS(11);
  494.     case 200: return AS(11);
  495.     default: return 0;
  496.     } 
  497. }
  498.  
  499. weight "ammo_belt"
  500. {
  501.     switch(INVENTORY_BELT)
  502.     {
  503.     case 20: return AS(30);
  504.     case 40: return AS(11);
  505.     case 60: return AS(11);
  506.     case 80: return AS(11);
  507.     case 100: return AS(11);
  508.     case 120: return AS(11);
  509.     case 140: return AS(11);
  510.     case 160: return AS(11);
  511.     case 180: return AS(11);
  512.     case 200: return AS(11);
  513.     default: return 0;
  514.     } 
  515. }
  516.  
  517.  
  518. //needs work
  519.  
  520. weight "holdable_teleporter"
  521. {
  522.     switch(INVENTORY_TELEPORTER)
  523.     {
  524.     case 1: return PS(TELW);
  525.     default: return 0;
  526.     } 
  527. } 
  528.  
  529. weight "holdable_medkit"
  530. {
  531.     switch(INVENTORY_TELEPORTER)
  532.     {
  533.     case 1: return PS(MEDW);
  534.     default: return 0; 
  535.     } 
  536. } 
  537.  
  538. weight "holdable_kamikaze"
  539. {
  540.     switch(INVENTORY_TELEPORTER)
  541.     {
  542.     case 1: return PS(KAMW);
  543.     default: return 0; 
  544.     } 
  545. } 
  546.  
  547. weight "holdable_portal"
  548. {
  549.     switch(INVENTORY_TELEPORTER)
  550.     {
  551.     case 1: return PS(PORW);
  552.     default: return 0; 
  553.     } 
  554. } 
  555.  
  556. weight "holdable_invulnerability"
  557. {
  558.     switch(INVENTORY_TELEPORTER)
  559.     {
  560.     case 1: return PS(IBW);
  561.     default: return 0; 
  562.     } 
  563. } 
  564.  
  565. weight "item_quad"
  566. {
  567.     return PS(QW);
  568. } 
  569.  
  570. weight "item_enviro"
  571. {
  572.     return PS(ENVW);
  573. } 
  574.  
  575. weight "item_haste"
  576. {
  577.     return PS(HAW);
  578. } 
  579.  
  580. weight "item_invisibility"
  581. {
  582.     return PS(INW);
  583. } 
  584.  
  585. weight "item_regen"
  586. {
  587.     return PS(REGW);
  588. } 
  589.  
  590. weight "item_flight"
  591. {
  592.     return PS(FLW);
  593. } 
  594.  
  595. weight "item_scout"
  596. {
  597.     switch(INVENTORY_SCOUT)
  598.     {
  599.     case 1: return PS(SCW);
  600.     default: return 0; 
  601.     }  
  602. } 
  603.  
  604. weight "item_guard"
  605. {
  606.     switch(INVENTORY_SCOUT)
  607.     {
  608.     case 1: return PS(GUW);
  609.     default: return 0; 
  610.     } 
  611. } 
  612.  
  613. weight "item_doubler"
  614. {
  615.     switch(INVENTORY_SCOUT)
  616.     {
  617.     case 1: return PS(DUBW);
  618.     default: return 0; 
  619.     }
  620. } 
  621.  
  622. weight "item_ammoregen"
  623. {
  624.     switch(INVENTORY_SCOUT)
  625.     {
  626.     case 1: return PS(AMRW);
  627.     default: return 0; 
  628.     } 
  629. } 
  630.  
  631.  
  632. //=============================================
  633. // This is only used to pickup dropped CTF
  634. // flags now. The logic in here makes no
  635. // sense since the bot has specific CTF AI.
  636. // yet without it the bots barely move towards 
  637. // the opposing flags due to low flag weights.
  638. //=============================================
  639.  
  640. weight "team_CTF_redflag" 
  641. {
  642.     switch(INVENTORY_REDFLAG)
  643.     {
  644.     case 1: return FGW;
  645.     default: return 300;
  646.     } 
  647. } 
  648.  
  649. weight "team_CTF_blueflag" 
  650. {
  651.     switch(INVENTORY_BLUEFLAG)
  652.     {
  653.     case 1: return FGW;
  654.     default: return 300;
  655.     } 
  656. } 
  657.  
  658.  
  659. weight "team_CTF_neutralflag" 
  660. {
  661.     return FGW;
  662. } 
  663.  
  664. weight "item_redcube" 
  665. {
  666.     return REDCW;
  667. } 
  668.  
  669. weight "item_bluecube" 
  670. {
  671.     return BLCW;
  672. } 
  673.  
  674. weight "item_botroam"
  675. {
  676.     return 1;
  677. } 
  678.  
  679.