Quantcast
Jump to content
Search In
  • More options...
Find results that contain...
Find results in...
    1. Welcome to GTAForums!

    1. GTANet.com

    1. GTA Online

      1. Los Santos Tuners
      2. Updates
      3. Find Lobbies & Players
      4. Guides & Strategies
      5. Vehicles
      6. Content Creator
      7. Help & Support
    2. Red Dead Online

      1. Blood Money
      2. Frontier Pursuits
      3. Find Lobbies & Outlaws
      4. Help & Support
    3. Crews

    1. Red Dead Redemption 2

      1. PC
      2. Help & Support
    2. Red Dead Redemption

    1. Grand Theft Auto Series

      1. St. Andrews Cathedral
    2. GTA VI

    3. GTA V

      1. Guides & Strategies
      2. Help & Support
    4. GTA IV

      1. The Lost and Damned
      2. The Ballad of Gay Tony
      3. Guides & Strategies
      4. Help & Support
    5. GTA San Andreas

      1. Guides & Strategies
      2. Help & Support
    6. GTA Vice City

      1. Guides & Strategies
      2. Help & Support
    7. GTA III

      1. Guides & Strategies
      2. Help & Support
    8. Portable Games

      1. GTA Chinatown Wars
      2. GTA Vice City Stories
      3. GTA Liberty City Stories
    9. Top-Down Games

      1. GTA Advance
      2. GTA 2
      3. GTA
    1. GTA Mods

      1. GTA V
      2. GTA IV
      3. GTA III, VC & SA
      4. Tutorials
    2. Red Dead Mods

      1. Documentation
    3. Mod Showroom

      1. Scripts & Plugins
      2. Maps
      3. Total Conversions
      4. Vehicles
      5. Textures
      6. Characters
      7. Tools
      8. Other
      9. Workshop
    4. Featured Mods

      1. Design Your Own Mission
      2. OpenIV
      3. GTA: Underground
      4. GTA: Liberty City
      5. GTA: State of Liberty
    1. Rockstar Games

    2. Rockstar Collectors

    1. Off-Topic

      1. General Chat
      2. Gaming
      3. Technology
      4. Movies & TV
      5. Music
      6. Sports
      7. Vehicles
    2. Expression

      1. Graphics / Visual Arts
      2. GFX Requests & Tutorials
      3. Writers' Discussion
      4. Debates & Discussion
    1. Announcements

      1. GTANet 20th Anniversary
    2. Support

    3. Suggestions

Edditing Mod ( Need help from C++ experts )


Eeklynt
 Share

Recommended Posts

Ok i edited to mod properly , handled all of the errors etc but mod is not working in game.Anyone can tell what can be the cause ? I would understand if the part i edited did not work but whole mod is not working so i messed somehow but i dont know which part of it.

here is the whole script ;

Spoiler

 

/*
Human needs v.0.3

TODO:
*/

//#define TestMode

#include "script.h"
#include <string>
#include <cstdlib>
#include <ctime>
#include "iostream"
#include "keyboard.h"
#include "IniWriter.h"
#include "IniReader.h"


#pragma warning(disable : 4244 4305 4800)

//konstanty
const unsigned __int8
    C_DEFAULT_AUTOSAVE_BY                = 1,
    C_DEFAULT_LINDEX                    = 0,
    C_DEFAULT_ANIMLOOPCOUNT                = 1,
    C_DEFAULT_MAXCARRYGOODSCOUNT        = 15,
    C_DEFAULT_GOODSCOUNT_PNQ            = 0,
    C_DEFAULT_GOODSCOUNT_EGOCHASER        = 0,
    C_DEFAULT_GOODSCOUNT_METEORITE        = 0,
    C_DEFAULT_GOODSCOUNT_ECOLA            = 0,
    C_DEFAULT_GOODSCOUNT_REDWOOD        = 0,
    C_DEFAULT_GOODSCOUNT_PISWASSER        = 0;

const int
    C_DEFAULT_MAXFOODLEVEL                = 9000,
    C_DEFAULT_MAXSLEEPLEVEL                = 13500,
    C_DEFAULT_MAXFUNLEVEL                = 15300,
    C_DEFAULT_COSTPNQ                    = 1,
    C_DEFAULT_COSTEGOCHASER                = 2,
    C_DEFAULT_COSTMETEORITE                = 4,
    C_DEFAULT_COSTECOLA                    = 3,
    C_DEFAULT_COSTPISWASSER                = 6,
    C_DEFAULT_COSTREDWOOD                = 24,
    C_DEFAULT_COSTCOFFEE                = 13,
    C_DEFAULT_COSTRESTAURANT            = 37,
    C_DEFAULT_COSTMOTEL                    = 135,
    C_DEFAULT_NEEDSSTATSBGINTENSITY        = 25;

const DWORD
    C_DEFAULT_NEEDSTIMERTIME            = 1000;

const float
    C_DEFAULT_NEEDSSTATSLEFT            = 0.163,
    C_DEFAULT_NEEDSSTATSTOP                = 0.92;

const bool
    C_DEFAULT_FOODENABLED                = true,
    C_DEFAULT_SLEEPENABLED                = true,
    C_DEFAULT_FUNENABLED                = true,
    C_DEFAULT_SHOWSHOPBLIPS                = true,
    C_DEFAULT_SHOWLIQUORBLIPS            = true,
    C_DEFAULT_SHOWRESTAURANTBLIPS        = true,
    C_DEFAULT_SHOWMOTELBLIPS            = true,
    C_DEFAULT_SHOWCOFFEEBLIPS            = true,
    C_DEFAULT_SHOWNEEDSSTATSATSTARTUP    = true;

/*const*/ char
    *C_DEFAULT_KEY_INV                        = "0x4E",
    *C_DEFAULT_KEY_ACTION                    = "0x45",
    *C_DEFAULT_KEY_MENUACTION                = "0x65",
    *C_DEFAULT_KEY_MENUUP                    = "0x68",
    *C_DEFAULT_KEY_MENUDOWN                    = "0x62",
    *C_DEFAULT_KEY_MENUCLOSE                = "0x60",
    *C_DEFAULT_KEY_NEEDSSTATSDISPLAYSWITCH    = "0x4F",
    *C_DEFAULT_KEY_SAVEDATA                    = "0x11+0x53",
    *C_DEFAULT_KEY_LOADDATA                    = "0x11+0x4C",
    *C_DEFAULT_KEY_RESETNEEDS                = "0x11+0x52",
    //*C_DEFAULT_KEY_SWITCHLANG                = "0x67",

    *C_INI_SECTION_OPTIONS                    = "Options",
    *C_INI_SECTION_KEYS                        = "Keys",
    *C_INI_SECTION_MICHAEL                    = "Michael",
    *C_INI_SECTION_FRANKLIN                    = "Franklin",
    *C_INI_SECTION_TREVOR                    = "Trevor",
    *C_INI_SECTION_MP                       = "MP",

    *C_INI_VALUE_FOODENABLED                = "FoodEnabled",
    *C_INI_VALUE_SLEEPENABLED                = "SleepEnabled",
    *C_INI_VALUE_FUNENABLED                    = "FunEnabled",
    *C_INI_VALUE_MAXFOODLEVEL                = "MaxFoodLevel",
    *C_INI_VALUE_MAXSLEEPLEVEL                = "MaxSleepLevel",
    *C_INI_VALUE_MAXFUNLEVEL                = "MaxFunLevel",
    *C_INI_VALUE_NEEDSTIMERTIME                = "NeedsTimerTime",
    *C_INI_VALUE_LINDEX                        = "LanguageIndex",
    *C_INI_VALUE_AUTOSAVE_BY                = "AutosaveBy",
    *C_INI_VALUE_ANIMLOOPCOUNT                = "AnimLoopCount",
    *C_INI_VALUE_MAXCARRYGOODSCOUNT            = "MaxCarryGoodsCount",
    *C_INI_VALUE_COSTPNQ                    = "CostPnQ",
    *C_INI_VALUE_COSTEGOCHASER                = "CostEgoChaser",
    *C_INI_VALUE_COSTMETEORITE                = "CostMeteorite",
    *C_INI_VALUE_COSTECOLA                    = "CostECola",
    *C_INI_VALUE_COSTPISWASSER                = "CostPiswasser",
    *C_INI_VALUE_COSTREDWOOD                = "CostRedwood",
    *C_INI_VALUE_COSTCOFFEE                    = "CostCoffee",
    *C_INI_VALUE_COSTRESTAURANT                = "CostRestaurant",
    *C_INI_VALUE_COSTMOTEL                    = "CostMotel",
    *C_INI_VALUE_SHOWSHOPBLIPS                = "ShowShopBlips",
    *C_INI_VALUE_SHOWLIQUORBLIPS            = "ShowLiquorBlips",
    *C_INI_VALUE_SHOWRESTAURANTBLIPS        = "ShowRestaurantBlips",
    *C_INI_VALUE_SHOWMOTELBLIPS                = "ShowMotelBlips",
    *C_INI_VALUE_SHOWCOFFEEBLIPS            = "ShowCoffeeBlips",

    *C_INI_VALUE_NEEDSSTATSLEFT                = "NeedsStatsLeft",
    *C_INI_VALUE_NEEDSSTATSTOP                = "NeedsStatsTop",
    *C_INI_VALUE_NEEDSSTATSBGINTENSITY        = "NeedsStatsBgIntensity",
    *C_INI_VALUE_SHOWNEEDSSTATSATSTARTUP    = "ShowNeedsStatsAtStartup",

    *C_INI_VALUE_KEY_INV                    = "Inventory",
    *C_INI_VALUE_KEY_ACTION                    = "Action",
    *C_INI_VALUE_KEY_MENUACTION                = "MenuAction",
    *C_INI_VALUE_KEY_MENUUP                    = "MenuUp",
    *C_INI_VALUE_KEY_MENUDOWN                = "MenuDown",
    *C_INI_VALUE_KEY_MENUCLOSE                = "MenuClose",
    *C_INI_VALUE_KEY_NEEDSSTATSDISPLAYSWITCH= "NeedsStatsDisplaySwitch",
    *C_INI_VALUE_KEY_SAVEDATA                = "SaveData",
    *C_INI_VALUE_KEY_LOADDATA                = "LoadData",
    *C_INI_VALUE_KEY_RESETNEEDS                = "ResetNeeds",
    //*C_INI_VALUE_KEY_SWITCHLANG            = "SwitchLanguage",

    *C_INI_VALUE_FOODLEVEL                    = "FoodLevel",
    *C_INI_VALUE_SLEEPLEVEL                    = "SleepLevel",
    *C_INI_VALUE_FUNLEVEL                    = "FunLevel",
    *C_INI_VALUE_GOODSCOUNT_PNQ                = "PnQ",
    *C_INI_VALUE_GOODSCOUNT_EGOCHASER        = "EgoChaser",
    *C_INI_VALUE_GOODSCOUNT_METEORITE        = "Meteorite",
    *C_INI_VALUE_GOODSCOUNT_ECOLA            = "ECola",
    *C_INI_VALUE_GOODSCOUNT_PISWASSER        = "Piswasser",
    *C_INI_VALUE_GOODSCOUNT_REDWOOD            = "Redwood";

//[typ barevneho schematu][barva polozky menu/barva textu][kanaly RGB a alpha]
const int menuItemColors[5][2][4] = {                                        //!!! nemen poradi barev
    { { {0}, {0}, {0}, {220} },            { {255}, {255}, {255}, {220} } },    //miNormal
    { { {255}, {255}, {255}, {220} },    { {0}, {0}, {0}, {220} } },            //miActive
    { { {0}, {0}, {0}, {220} },            { {255}, {255}, {255}, {220} } },    //miTitleInventory - barva pozadi vybirana v DrawMenuItem, dle aktivniho hrace
    { { {186}, {95}, {235}, {220} },    { {255}, {255}, {255}, {220} } },    //miTitleBuyFood
    { { {231}, {18}, {29}, {220} },        { {255}, {255}, {255}, {220} } }    //miTitleBuyLiquor
};

const int needsStatsColors[6][4] = {
    { {138}, {255}, {0}, {220} },
    { {255}, {255}, {255}, {220} },
    { {244}, {229}, {0}, {220} },
    { {255}, {150}, {0}, {220} },
    { {237}, {14}, {0}, {220} },
    { {237}, {14}, {0}, {220} }
};

const int playersColors[3][3] = {
    { { 101 },{ 180 },{ 212 } },
    { { 171 },{ 237 },{ 171 } },
    { { 255 },{ 163 },{ 87 } },
};

const int msgColors[2][4] = {
    { {255}, {201}, {14}, {220} },    //podklad
    { {255}, {255}, {255}, {220} }    //text
};

const int actionPointColor[6][3] = {
    { {171}, {60}, {230} },    //pcFood
    { {224}, {50}, {50} },    //pcLiquor
    { {187}, {214}, {91} },    //pcRestaurant
    { {240}, {200}, {80} },    //pcMotel
    { {166}, {117}, {94} },    //pcCoffe
    { {204}, {204}, {0} }    //pcFridge
};

/*const*/ char* txts[14][2] = {
    { "Lose the cops", "Nejprve setres poldy" },
    { "Press \"%s\" to buy some snacks", "Stiskni \"%s\" pro nakup obcerstveni" },
    { "Press \"%s\" to buy a liquor or some cigarettes", "Stiskni \"%s\" pro nakup alkoholu a cigaret" },
    { "Press \"%s\" to eat at restaurant for $%d", "Stiskni \"%s\" pro najezeni v restauraci za $%d" },
    { "Press \"%s\" to sleep at motel for $%d", "Stiskni \"%s\" pro spanek v motelu za $%d" },
    { "Press \"%s\" to buy a coffee for $%d", "Stiskni \"%s\" pro zakoupeni kavy za $%d" },
    { "Press \"%s\" to eat from fridge", "Stiskni \"%s\" pro najezeni z lednicky" },
    { "Press \"%s\" to use", "Stiskni \"%s\" pro pouziti" },
    { "Inventory is full", "Inventar je plny" },
    { "You don't have enough money", "Nemas dostatek penez" },
    { "You don't have this goods", "Tohle zbozi nemas" },
    { "Data saved", "Data ulozena" },
    { "Data loaded", "Data nactena" },
    { "Needs restored", "Potreby obnoveny" },
};

/*const*/ char* txtsMenu[3][7][2] = {
    { { "P's & Q's", "P's & Q's" }, { "EgoChaser", "EgoChaser" }, { "Meteorite", "Meteorite" }, { "eCola", "eCola" }, { "Piswasser", "Piswasser" }, { "Redwood", "Redwood" }, { "Inventory", "Inventar" } },    //mInventory
    { { "buy P's & Q's", "kup P's & Q's" }, { "buy EgoChaser", "kup EgoChaser" }, { "buy Meteorite", "kup Meteorite" }, { "buy eCola", "kup eCola" }, { "", "" }, { "", "" }, { "Buy food", "Nakup jidla" } },    //mFood
    { { "buy Piswasser", "kup Piswasser" },{ "buy Redwood", "kup Redwood" }, { "", "" }, { "", "" }, { "", "" }, { "", "" }, { "Buy some cigarettes and liquor", "Nakup cigaret a alkoholu" } }                        //mLiquor
};

/*const*/ char* txtsMenuHint[6][2] = {
    { { "The candy bar that kids\nand stoners love.\n\n +10 health\n +10-20%% food\n\ncost $%d" }, { "Lentilky, ktere deti a vyhulenci\nmiluji.\n\n +10 zdravi\n +10-20%% jidla\n\ncena $%d" } },
    { { "Ego Chaser Energy Bars is\nchocolate bar.\n\n +20 health\n +20-30%% food\n\ncost $%d" }, { "Cokoladova tycinka s orechy\na karamelem.\n\n +20 zdravi\n +20-30%% jidla\n\ncena $%d" } },
    { { "It is a dark chocolate bar with\na gooey core.\n\n +30 health\n +30-50%% food\n\ncost $%d" }, { "Tycinka z tmave cokolady\na karamelizovanym vnitrkem.\n\n +30 zdravi\n +30-50%% jidla\n\ncena $%d" } },
    { { "eCola is a soft drink.\n\n +25 health\n +5-15%% food\n\ncost $%d" }, { "Nealkoholicky napoj. Hodne\ncukru, hodne kofeinu.\n\n +25 zdravi\n +5-15%% jidla\n\ncena $%d" } },
    { { "Beer - \"the fresh urine of\nBavarian virgins\".\n\n -3 health\n -7%% sleep\n +25%% fun\n\ncost $%d" }, { " Pivo - \"svezi chcanky\nbavorskych panen\".\n\n -3 zdravi\n -7%% spanku\n +25%% zabavy\n\ncena $%d" } },
    { { "Cigarettes for real men\nwithout the doctors.\n\n -8 health\n -2%% sleep\n +100%% fun\n\ncost $%d (5pcs)" }, { "Cigarety pro opravdove muze\nbez doktoru.\n\n -8 zdravi\n -2%% spanku\n +100%% zabavy\n\ncena $%d (5ks)" } }
};

/*const*/ char* txtsBlipsNames[7][2] = {
    { { "Food store" }, { "Potraviny" }, },
    { { "Liquor store" }, { "Trafika" }, },
    { { "Restaurant" }, { "Restaurace" }, },
    { { "Motel" }, { "Motel" }, },
    { { "Coffee shop" }, { "Kavarna" }, },
    { { "Fridge" }, { "Lednicka" }, }
};

/*const*/ char* txtsNeeds[3][2] = {
    { { "Food:\t%d %%" }, { "Jidlo:\t%d %%" } },
    { { "Sleep:\t%d %%" }, { "Spanek:\t%d %%" } },
    { { "Fun:\t\t%d %%" }, { "Zabava:\t%d %%" } }
};

struct AnimParamsType
{
    std::string objName;
    int boneID;
    float objX, objY, objZ, objRotX, objRotY, objRotZ;
    DWORD amimTime1, waitTime1, animTime2, waitTime2, terminationTime;
    std::string anim1_Dict, anim1_Name, anim2_Dict, anim2_Name, effectPTFX, effectName;
    float effX, effY, effZ, effRotX, effRotY, effRotZ;
    int effBoneID;
};

const AnimParamsType animParams[7] = {
    { "prop_candy_pqs", 4089, 0.07f, -0.05f, 0.02f, -55.0f, 0.0f, 0.0f, 2200, 3200, 0, 0, 500, "[email protected]", "loop", "", "", "", "", 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0 },
    { "prop_choc_ego", 4089, 0.06f, -0.02f, -0.02f, 0.0f, -20.0f, -120.0f, 1800, 2800, 0, 0, 500, "[email protected]", "mp_player_int_eat_burger", "", "", "", "", 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0 },
    { "prop_choc_meto", 4089, 0.06f, -0.02f, -0.02f, 0.0f, -20.0f, -120.0f, 1800, 2800, 0, 0, 500, "[email protected]", "mp_player_int_eat_burger", "", "", "", "", 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0 },
    { "prop_ecola_can", 4089, 0.02f, -0.05f, 0.03f, 195.0f, -30.0f, 0.0f, 2200, 2600, 0, 0, 0, "mp_player_intdrink", "loop", "", "", "", "", 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0 },
    { "prop_amb_beer_bottle", 4089, 0.01f, -0.06f, 0.07f, -30.0f, 165.0f, -30.0f, 2400, 2900, 0, 0, 0, "mp_player_intdrink", "loop_bottle", "", "", "", "", 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0 },
    { "prop_amb_ciggy_01", 4169, 0.02f, -0.01f, -0.005f, 0.0f, -10.0f, -110.0f, 2200, 700, 0, 3200, 500, "mp_player_int_uppersmoke", "mp_player_int_smoke", "", "", "scr_carsteal4", "scr_carsteal4_wheel_burnout", 0.0f, -0.5f, 0.0f, 90.0f, 0.0f, 0.0f, 3651 },
    { "p_amb_coffeecup_01", 64016, 0.06f, -0.03f, 0.04f, -20.0f, 30.0f, 0.0f, 2200, 2000, 1700, 1500, 500, "[email protected][email protected]@[email protected]_a", "idle_a", "[email protected][email protected]@[email protected]", "base", "", "", 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0 }
};

enum PointCategoryType { pcFood, pcLiquor, pcRestaurant, pcMotel, pcCoffee, pcFridge, pcNone };

struct ActionPointsType {
    float x, y, z;
    int sprite, color;
    PointCategoryType type;
};

const ActionPointsType actionPointsParams[56] = {    //{x} {y} {z} {sprite id} {barva} {kategorie}
    { { 33.96f },    { -1343.21f },    { 29.49f },    { 52 }, { 27 },    { pcFood } },
    { { -52.68f },    { -1747.71f },    { 29.42f },    { 52 },    { 27 },    { pcFood } },
    { { 1153.03f },    { -320.50f },    { 69.20f },    { 52 }, { 27 },    { pcFood } },
    { { 2553.69f },    { 390.48f },    { 108.62f },{ 52 }, { 27 },    { pcFood } },
    { { -1831.16f },{ 789.74f },    { 138.31f },{ 52 }, { 27 },    { pcFood } },
    { { -3045.70f },{ 592.30f },    { 7.90f },    { 52 }, { 27 },    { pcFood } },
    { { -3245.33f },{ 1009.75f },    { 12.83f },    { 52 }, { 27 },    { pcFood } },
    { { -717.26f },    { -909.69f },    { 19.21f },    { 52 }, { 27 },    { pcFood } },
    { { 540.22f },    { 2666.06f },    { 42.15f },    { 52 }, { 27 },    { pcFood } },
    { { 2679.16f },    { 3289.64f },    { 55.24f },    { 52 }, { 27 },    { pcFood } },
    { { 1966.32f },    { 3748.16f },    { 32.34f },    { 52 }, { 27 },    { pcFood } },
    { { 1707.82f },    { 4929.66f },    { 42.06f },    { 52 }, { 27 },    { pcFood } },
    { { 1738.13f },    { 6414.62f },    { 35.03f },    { 52 }, { 27 },    { pcFood } },
    { { 382.68f },    { 327.91f },    { 103.56f },{ 52 }, { 27 },    { pcFood } },
    { { 1136.94f },    { -979.01f },    { 46.41f },    { 52 },    { 1 },    { pcLiquor } },
    { { -1226.07f },{ -907.25f },    { 12.32f },    { 52 },    { 1 },    { pcLiquor } },
    { { -1486.40f },{ -382.37f },    { 40.16f },    { 52 },    { 1 },    { pcLiquor } },
    { { -2969.68f },{ 387.94f },    { 15.04f },    { 52 },    { 1 },    { pcLiquor } },
    { { 1169.00f },    { 2707.68f },    { 38.15f },    { 52 },    { 1 },    { pcLiquor } },
    { { -1182.93f },{ -883.92f },    { 13.75f },    { 93 },    { 24 },    { pcRestaurant } },
    { { -1687.57f },{ -1092.02f },    { 13.15f },    { 93 },    { 24 },    { pcRestaurant } },
    { { -1552.40f },{ -440.19f },    { 40.51f },    { 93 },    { 24 },    { pcRestaurant } },
    { { -1198.05f },{ -792.00f },    { 16.35f },    { 93 },    { 24 },    { pcRestaurant } },
    { { -657.49f },    { -678.90f },    { 31.47f },    { 93 },    { 24 },    { pcRestaurant } },
    { { -1546.65f },{ -467.20f },    { 36.18f },    { 93 },    { 24 },    { pcRestaurant } },
    { { 81.35f },    { 274.44f },    { 110.21f },{ 93 },    { 24 },    { pcRestaurant } },
    { { 1590.45f },    { 6448.58f },    { 25.31f },    { 93 },    { 24 },    { pcRestaurant } },
    { { 132.37f },    { -1462.06f },    { 29.35f },    { 93 },    { 24 },    { pcRestaurant } },
    { { 556.11f },    { -1758.89f },    { 33.44f },    { 374 },{ 5 },    { pcMotel } },
    { { 366.59f },    { 2625.34f },    { 44.66f },    { 374 },{ 5 },    { pcMotel } },
    { { -1338.83f },{ -941.20f },    { 12.05f },    { 374 },{ 5 },    { pcMotel } },
    { { -101.85f },    { 6344.84f },    { 35.50f },    { 374 },{ 5 },    { pcMotel } },
    { { -1481.53f },{ -652.98f },    { 29.58f },    { 374 },{ 5 },    { pcMotel } },
    { { 321.10f },    { -197.78f },    { 58.01f },    { 374 },{ 5 },    { pcMotel } },
    { { 1141.13f },    { 2654.67f },    { 38.15f },    { 374 },{ 5 },    { pcMotel } },
    { { -11.85f },    { 516.64f },    { 174.62f },{ 0 },    { 0 },    { pcFridge } },
    { { -803.35f },    { 185.68f },    { 72.60f },    { 0 },    { 0 },    { pcFridge } },
    { { 1973.06f },    { 3819.37f },    { 33.42f },    { 0 },    { 0 },    { pcFridge } },
    { { 93.24f },    { -1291.39f },    { 29.26f },    { 0 },    { 0 },    { pcFridge } },
    { { -10.23f },    { -1430.29f },    { 31.10f },    { 0 },    { 0 },    { pcFridge } },
    { { -1153.85f },{ 1520.11f },    { 10.63f },    { 0 },    { 0 },    { pcFridge } },
    { { 263.92f },    { -981.31f },    { 29.36f },    { 52 },    { 21 },    { pcCoffee } },
    { { 1181.48f },    { -410.19f },    { 67.67f },    { 52 },    { 21 },    { pcCoffee } },
    { { -1280.42f },{ -878.17f },    { 11.92f },    { 52 },    { 21 },    { pcCoffee } },
    { { -1207.66f },{ -1134.89f },    { 7.72f },    { 52 },    { 21 },    { pcCoffee } },
    { { -628.46f },    { 239.07f },    { 81.89f },    { 52 },    { 21 },    { pcCoffee } },
    { { -842.35f },    { -606.14f },    { 29.02f },    { 52 },    { 21 },    { pcCoffee } },
    { { -1367.91f },{ -209.48f },    { 44.42f },    { 52 },    { 21 },    { pcCoffee } },
    { { -1703.37f },{ -1099.71f },    { 13.15f },    { 52 },    { 21 },    { pcCoffee } },
    { { 460.14f },    { -719.34f },    { 27.35f },    { 52 },    { 21 },    { pcCoffee } },
    { { 280.27f },    { -962.58f },    { 29.41f },    { 52 },    { 21 },    { pcCoffee } },
    { { -1349.51f },{ -615.35f },    { 28.61f },    { 52 },    { 21 },    { pcCoffee } },
    { { -841.04f },    { -351.25f },    { 38.68f },    { 52 },    { 21 },    { pcCoffee } },
    { { -240.23f },    { -777.18f },    { 34.09f },    { 52 },    { 21 },    { pcCoffee } },
    { { -630.40f },    { -301.74f },    { 35.34f },    { 52 },    { 21 },    { pcCoffee } },
    { { -1548.77f },{ -436.20f },    { 35.88f },    { 52 },    { 21 },    { pcCoffee } }
};

//!!! nemen poradi ve vyctovych typech
enum PlayerType { pMICHAEL, pFRANKLIN, pTREVOR, pUNKNOWN, pMP };

enum NeedType { nFood, nSleep, nFun, nAll, _First = nFood, _Last = nFun };

enum LoadSettingKindType { lskOptions, lskPlayerData };

enum SaveSettingKindType { sskFoodLevel, sskSleepLevel, sskFunLevel, sskAllNeedsLevels, sskGoods };

enum MenuItemType { miNormal, miActive, miTitleInventory, miTitleBuyFood, miTitleBuyLiquor };

enum MenuType { mNone, mInventory, mFood, mLiquor };

enum AnimType { aEatPnQ, aEatEgo, aEatMet, aDrinkCoke, aDrinkBeer, aSmoke, aDrinkCoffee, aNone };

enum GoodsType { gPnQ, gEgo, gMet, gCola, gBeer, gCigarette, gCoffe, gLunch, gRoom };

enum SoundType { sBeep, sDelete};

enum DrunkModeStateType { dmsStopped, dmsStart, dmsProceeds, dmsStop };

struct KeysType
{
    DWORD inv, action, menuAction, menuUp, menuDown, menuClose, needsStatsDisplaySwitch, saveDataCmb, saveData, loadDataCmb, loadData, resetNeedsCmb, resetNeeds/*, switchLang*/;
};

struct CurrPlayerStatsType
{
    int needsLevels[3];
    unsigned __int8 goodsCounts[6], needsStatuses[3];
};

struct PositionType
{
    float x, y;
};

struct DataStoreType
{
    unsigned __int8
        autosaveBy,
        lIndex,
        animLoopCount,
        maxCarryGoodsCount,
        activeNeedsCount = 0;
    int
        maxNeedsLevels[3],
        goodsPrices[9],    //v poradi: enum GoodsType { gPnQ, gEgo, gMet, gCola, gBeer, gCigarette, gCoffe, gLunch, gRoom };
        needsStatsBgIntensity;
    DWORD needsTimerTime;
    PositionType
        needsStatsPos;
    bool
        autosaveAllowed,
        animAllowed,
        needsEnabled[3],
        showBlips[5],
        showNeedsStats;

    CurrPlayerStatsType currPlayerStats;
};

struct CurrMenuType
{
    //proporce - hodnoty se plni v DoScaleMenuProportion
    float    xS,
            yS,
            itemWidthS,
            itemHeightS,
            textItemLeftS,
            textItemValueLeftS,
            textTitleLeftS,
            textHintLeftS;
    //hodnoty aktualniho menu
    MenuType type = mNone;
    MenuItemType titleType = miNormal;
    int    itemCount = 0,
        itemMaxCount = 6,
        startItemIndex = 0,
        activeItem = 0,
        txtsIndex = -1;
};

Ped currPlayerPed_ID = NULL;
Player currPlayer_ID = NULL;
PlayerType currPlayer = pUNKNOWN;
KeysType keys;
DataStoreType dataStore;
CurrMenuType currMenu;
CIniReader settingReader(".\\HumanNeeds.ini");
CIniWriter settingWriter(".\\HumanNeeds.ini");
int scrCurrActiveResW = 0, scrCurrActiveResH = 0;    //aktivni rozliseni - hodnoty se plni v ActiveResChanged
float textCurrScale = 0.35,                            //hodnota se vzdy prepocita dle aktivniho rozliseni
    hPosAdjust = 0.0;
std::string currMsg = "";
DWORD currMsgTime = 0, needsTimer = 0, drunkTime = 0, negTimerFood = 0;
bool currMsgCanShow = false, jumpDone = true, keysPressed = false, ownSADisabled = false;
char needTxtBuffer[100], hBuffer[100], menuHintBuffer[250];
DrunkModeStateType drunkModeState = dmsStopped;
int memHours, currHours, bundle;
__int8 memNeedsPer[3] = { -1, -1, -1 };
GoodsType goodsItem;

#ifdef TestMode
    int testType = 0;
#endif

char* GetCurrPlayerINISection()
{
    if (currPlayer == pMICHAEL) return C_INI_SECTION_MICHAEL;
    else if (currPlayer == pFRANKLIN) return C_INI_SECTION_FRANKLIN;
    else if (currPlayer == pTREVOR) return C_INI_SECTION_TREVOR;
    else if (currPlayer == pMP) return C_INI_SECTION_MP;
    else return "";
}

void SaveSettings(SaveSettingKindType aWhat)
{
    if (currPlayer != pUNKNOWN)
    {
        char* pSec = GetCurrPlayerINISection();
        switch (aWhat)
        {
            case sskAllNeedsLevels:
            case sskFoodLevel:
                if (dataStore.needsEnabled[nFood])
                    settingWriter.WriteInteger(pSec, C_INI_VALUE_FOODLEVEL, dataStore.currPlayerStats.needsLevels[nFood]);
                if (aWhat == sskFoodLevel) break;
            case sskSleepLevel:
                if (dataStore.needsEnabled[nSleep])
                    settingWriter.WriteInteger(pSec, C_INI_VALUE_SLEEPLEVEL, dataStore.currPlayerStats.needsLevels[nSleep]);
                if (aWhat == sskSleepLevel) break;
            case sskFunLevel:
                if (dataStore.needsEnabled[nFun])
                    settingWriter.WriteInteger(pSec, C_INI_VALUE_FUNLEVEL, dataStore.currPlayerStats.needsLevels[nFun]);
                break;
            case sskGoods:
                settingWriter.WriteInteger(pSec, C_INI_VALUE_GOODSCOUNT_PNQ, dataStore.currPlayerStats.goodsCounts[gPnQ]);
                settingWriter.WriteInteger(pSec, C_INI_VALUE_GOODSCOUNT_EGOCHASER, dataStore.currPlayerStats.goodsCounts[gEgo]);
                settingWriter.WriteInteger(pSec, C_INI_VALUE_GOODSCOUNT_METEORITE, dataStore.currPlayerStats.goodsCounts[gMet]);
                settingWriter.WriteInteger(pSec, C_INI_VALUE_GOODSCOUNT_ECOLA, dataStore.currPlayerStats.goodsCounts[gCola]);
                settingWriter.WriteInteger(pSec, C_INI_VALUE_GOODSCOUNT_REDWOOD, dataStore.currPlayerStats.goodsCounts[gCigarette]);
                settingWriter.WriteInteger(pSec, C_INI_VALUE_GOODSCOUNT_PISWASSER, dataStore.currPlayerStats.goodsCounts[gBeer]);
                break;
        }
    }
}

void LoadSettings(LoadSettingKindType aWhat)
{
    std::string hStr;
    switch (aWhat)
    {
        case lskOptions:
            dataStore.needsEnabled[nFood]        = settingReader.ReadBoolean(C_INI_SECTION_OPTIONS, C_INI_VALUE_FOODENABLED, C_DEFAULT_FOODENABLED);
            dataStore.needsEnabled[nSleep]        = settingReader.ReadBoolean(C_INI_SECTION_OPTIONS, C_INI_VALUE_SLEEPENABLED, C_DEFAULT_SLEEPENABLED);
            dataStore.needsEnabled[nFun]        = settingReader.ReadBoolean(C_INI_SECTION_OPTIONS, C_INI_VALUE_FUNENABLED, C_DEFAULT_FUNENABLED);
            for (NeedType hNeed = _First; hNeed <= _Last; hNeed = NeedType(hNeed + 1))
                dataStore.activeNeedsCount += dataStore.needsEnabled[hNeed];
            dataStore.maxNeedsLevels[nFood]        = settingReader.ReadInteger(C_INI_SECTION_OPTIONS, C_INI_VALUE_MAXFOODLEVEL, C_DEFAULT_MAXFOODLEVEL);
            dataStore.maxNeedsLevels[nSleep]    = settingReader.ReadInteger(C_INI_SECTION_OPTIONS, C_INI_VALUE_MAXSLEEPLEVEL, C_DEFAULT_MAXSLEEPLEVEL);
            dataStore.maxNeedsLevels[nFun]        = settingReader.ReadInteger(C_INI_SECTION_OPTIONS, C_INI_VALUE_MAXFUNLEVEL, C_DEFAULT_MAXFUNLEVEL);
            dataStore.needsTimerTime            = settingReader.ReadInteger(C_INI_SECTION_OPTIONS, C_INI_VALUE_NEEDSTIMERTIME, C_DEFAULT_NEEDSTIMERTIME);
            dataStore.showBlips[pcFood]            = settingReader.ReadBoolean(C_INI_SECTION_OPTIONS, C_INI_VALUE_SHOWSHOPBLIPS, C_DEFAULT_SHOWSHOPBLIPS);
            dataStore.showBlips[pcLiquor]        = settingReader.ReadBoolean(C_INI_SECTION_OPTIONS, C_INI_VALUE_SHOWLIQUORBLIPS, C_DEFAULT_SHOWLIQUORBLIPS);
            dataStore.showBlips[pcRestaurant]    = settingReader.ReadBoolean(C_INI_SECTION_OPTIONS, C_INI_VALUE_SHOWRESTAURANTBLIPS, C_DEFAULT_SHOWRESTAURANTBLIPS);
            dataStore.showBlips[pcMotel]        = settingReader.ReadBoolean(C_INI_SECTION_OPTIONS, C_INI_VALUE_SHOWMOTELBLIPS, C_DEFAULT_SHOWMOTELBLIPS);
            dataStore.showBlips[pcCoffee]        = settingReader.ReadBoolean(C_INI_SECTION_OPTIONS, C_INI_VALUE_SHOWCOFFEEBLIPS, C_DEFAULT_SHOWCOFFEEBLIPS);
            dataStore.needsStatsPos.x            = settingReader.ReadFloat(C_INI_SECTION_OPTIONS, C_INI_VALUE_NEEDSSTATSLEFT, C_DEFAULT_NEEDSSTATSLEFT);
            dataStore.needsStatsPos.y            = settingReader.ReadFloat(C_INI_SECTION_OPTIONS, C_INI_VALUE_NEEDSSTATSTOP, C_DEFAULT_NEEDSSTATSTOP);
            dataStore.needsStatsBgIntensity        = settingReader.ReadInteger(C_INI_SECTION_OPTIONS, C_INI_VALUE_NEEDSSTATSBGINTENSITY, C_DEFAULT_NEEDSSTATSBGINTENSITY);
            dataStore.showNeedsStats            = settingReader.ReadBoolean(C_INI_SECTION_OPTIONS, C_INI_VALUE_SHOWNEEDSSTATSATSTARTUP, C_DEFAULT_SHOWNEEDSSTATSATSTARTUP);
            dataStore.autosaveBy                = settingReader.ReadInteger(C_INI_SECTION_OPTIONS, C_INI_VALUE_AUTOSAVE_BY, C_DEFAULT_AUTOSAVE_BY);
            dataStore.autosaveAllowed            = dataStore.autosaveBy > 0;
            dataStore.lIndex                    = settingReader.ReadInteger(C_INI_SECTION_OPTIONS, C_INI_VALUE_LINDEX, C_DEFAULT_LINDEX);
            dataStore.animLoopCount                = settingReader.ReadInteger(C_INI_SECTION_OPTIONS, C_INI_VALUE_ANIMLOOPCOUNT, C_DEFAULT_ANIMLOOPCOUNT);
            dataStore.animAllowed                = dataStore.animLoopCount > 0;
            dataStore.maxCarryGoodsCount        = settingReader.ReadInteger(C_INI_SECTION_OPTIONS, C_INI_VALUE_MAXCARRYGOODSCOUNT, C_DEFAULT_MAXCARRYGOODSCOUNT);
            dataStore.goodsPrices[gPnQ]            = settingReader.ReadInteger(C_INI_SECTION_OPTIONS, C_INI_VALUE_COSTPNQ, C_DEFAULT_COSTPNQ);
            dataStore.goodsPrices[gEgo]            = settingReader.ReadInteger(C_INI_SECTION_OPTIONS, C_INI_VALUE_COSTEGOCHASER, C_DEFAULT_COSTEGOCHASER);
            dataStore.goodsPrices[gMet]            = settingReader.ReadInteger(C_INI_SECTION_OPTIONS, C_INI_VALUE_COSTMETEORITE, C_DEFAULT_COSTMETEORITE);
            dataStore.goodsPrices[gCola]        = settingReader.ReadInteger(C_INI_SECTION_OPTIONS, C_INI_VALUE_COSTECOLA, C_DEFAULT_COSTECOLA);
            dataStore.goodsPrices[gBeer]        = settingReader.ReadInteger(C_INI_SECTION_OPTIONS, C_INI_VALUE_COSTPISWASSER, C_DEFAULT_COSTPISWASSER);
            dataStore.goodsPrices[gCigarette]    = settingReader.ReadInteger(C_INI_SECTION_OPTIONS, C_INI_VALUE_COSTREDWOOD, C_DEFAULT_COSTREDWOOD);
            dataStore.goodsPrices[gCoffe]        = settingReader.ReadInteger(C_INI_SECTION_OPTIONS, C_INI_VALUE_COSTCOFFEE, C_DEFAULT_COSTCOFFEE);
            dataStore.goodsPrices[gLunch]        = settingReader.ReadInteger(C_INI_SECTION_OPTIONS, C_INI_VALUE_COSTRESTAURANT, C_DEFAULT_COSTRESTAURANT);
            dataStore.goodsPrices[gRoom]        = settingReader.ReadInteger(C_INI_SECTION_OPTIONS, C_INI_VALUE_COSTMOTEL, C_DEFAULT_COSTMOTEL);
            keys.inv                            = std::strtoul(settingReader.ReadString(C_INI_SECTION_KEYS, C_INI_VALUE_KEY_INV, C_DEFAULT_KEY_INV), NULL, 16);
            keys.action                            = std::strtoul(settingReader.ReadString(C_INI_SECTION_KEYS, C_INI_VALUE_KEY_ACTION, C_DEFAULT_KEY_ACTION), NULL, 16);
            keys.menuAction                        = std::strtoul(settingReader.ReadString(C_INI_SECTION_KEYS, C_INI_VALUE_KEY_MENUACTION, C_DEFAULT_KEY_MENUACTION), NULL, 16);
            keys.menuUp                            = std::strtoul(settingReader.ReadString(C_INI_SECTION_KEYS, C_INI_VALUE_KEY_MENUUP, C_DEFAULT_KEY_MENUUP), NULL, 16);
            keys.menuDown                        = std::strtoul(settingReader.ReadString(C_INI_SECTION_KEYS, C_INI_VALUE_KEY_MENUDOWN, C_DEFAULT_KEY_MENUDOWN), NULL, 16);
            keys.menuClose                        = std::strtoul(settingReader.ReadString(C_INI_SECTION_KEYS, C_INI_VALUE_KEY_MENUCLOSE, C_DEFAULT_KEY_MENUCLOSE), NULL, 16);
            keys.needsStatsDisplaySwitch        = std::strtoul(settingReader.ReadString(C_INI_SECTION_KEYS, C_INI_VALUE_KEY_NEEDSSTATSDISPLAYSWITCH, C_DEFAULT_KEY_NEEDSSTATSDISPLAYSWITCH), NULL, 16);

            hStr = settingReader.ReadString(C_INI_SECTION_KEYS, C_INI_VALUE_KEY_SAVEDATA, C_DEFAULT_KEY_SAVEDATA);
            if ((hStr.length() != 9) && (hStr.length() != 4))
                hStr = C_DEFAULT_KEY_SAVEDATA;
            if (hStr.length() == 4)
            {
                keys.saveDataCmb = 0;
                keys.saveData = std::strtoul((char*)hStr.c_str(), NULL, 16);
            }
            else
            {
                keys.saveDataCmb = std::strtoul((char*)hStr.substr(0, 4).c_str(), NULL, 16);
                keys.saveData = std::strtoul((char*)hStr.substr(5, 4).c_str(), NULL, 16);
            }
            
            hStr = settingReader.ReadString(C_INI_SECTION_KEYS, C_INI_VALUE_KEY_LOADDATA, C_DEFAULT_KEY_LOADDATA);
            if ((hStr.length() != 9) && (hStr.length() != 4))
                hStr = C_DEFAULT_KEY_LOADDATA;
            if (hStr.length() == 4)
            {
                keys.loadDataCmb = 0;
                keys.loadData = std::strtoul((char*)hStr.c_str(), NULL, 16);
            }
            else
            {
                keys.loadDataCmb = std::strtoul((char*)hStr.substr(0, 4).c_str(), NULL, 16);
                keys.loadData = std::strtoul((char*)hStr.substr(5, 4).c_str(), NULL, 16);
            }

            hStr = settingReader.ReadString(C_INI_SECTION_KEYS, C_INI_VALUE_KEY_RESETNEEDS, C_DEFAULT_KEY_RESETNEEDS);
            if ((hStr.length() != 9) && (hStr.length() != 4))
                hStr = C_DEFAULT_KEY_RESETNEEDS;
            if (hStr.length() == 4)
            {
                keys.resetNeedsCmb = 0;
                keys.resetNeeds = std::strtoul((char*)hStr.c_str(), NULL, 16);
            }
            else
            {
                keys.resetNeedsCmb = std::strtoul((char*)hStr.substr(0, 4).c_str(), NULL, 16);
                keys.resetNeeds = std::strtoul((char*)hStr.substr(5, 4).c_str(), NULL, 16);
            }

            //keys.switchLang                        = std::strtoul(settingReader.ReadString(C_INI_SECTION_KEYS, C_INI_VALUE_KEY_SWITCHLANG, C_DEFAULT_KEY_SWITCHLANG), NULL, 16);
            break;
        case lskPlayerData:
            if (currPlayer != pUNKNOWN)
            {
                char* pSec = GetCurrPlayerINISection();
                dataStore.currPlayerStats.needsLevels[nFood]    = settingReader.ReadInteger(pSec, C_INI_VALUE_FOODLEVEL, C_DEFAULT_MAXFOODLEVEL);
                dataStore.currPlayerStats.needsLevels[nSleep]    = settingReader.ReadInteger(pSec, C_INI_VALUE_SLEEPLEVEL, C_DEFAULT_MAXSLEEPLEVEL);
                dataStore.currPlayerStats.needsLevels[nFun]        = settingReader.ReadInteger(pSec, C_INI_VALUE_FUNLEVEL, C_DEFAULT_MAXFUNLEVEL);
                dataStore.currPlayerStats.goodsCounts[gPnQ]            = settingReader.ReadInteger(pSec, C_INI_VALUE_GOODSCOUNT_PNQ, C_DEFAULT_GOODSCOUNT_PNQ);
                dataStore.currPlayerStats.goodsCounts[gEgo]            = settingReader.ReadInteger(pSec, C_INI_VALUE_GOODSCOUNT_EGOCHASER, C_DEFAULT_GOODSCOUNT_EGOCHASER);
                dataStore.currPlayerStats.goodsCounts[gMet]            = settingReader.ReadInteger(pSec, C_INI_VALUE_GOODSCOUNT_METEORITE, C_DEFAULT_GOODSCOUNT_METEORITE);
                dataStore.currPlayerStats.goodsCounts[gCola]        = settingReader.ReadInteger(pSec, C_INI_VALUE_GOODSCOUNT_ECOLA, C_DEFAULT_GOODSCOUNT_ECOLA);
                dataStore.currPlayerStats.goodsCounts[gCigarette]    = settingReader.ReadInteger(pSec, C_INI_VALUE_GOODSCOUNT_REDWOOD, C_DEFAULT_GOODSCOUNT_REDWOOD);
                dataStore.currPlayerStats.goodsCounts[gBeer]        = settingReader.ReadInteger(pSec, C_INI_VALUE_GOODSCOUNT_PISWASSER, C_DEFAULT_GOODSCOUNT_PISWASSER);
            }
    }
}

void PlaySnd(SoundType aWhat)
{
    switch (aWhat)
    {
        case sBeep:
            AUDIO::PLAY_SOUND_FRONTEND(-1, "NAV_UP_DOWN", "HUD_FRONTEND_DEFAULT_SOUNDSET", 0);
            break;
        case sDelete:
            AUDIO::PLAY_SOUND_FRONTEND(-1, "DELETE", "HUD_DEATHMATCH_SOUNDSET", 0);
            break;
    }
}

bool ActiveResChanged()
{
    int scrAW, scrAH;
    GRAPHICS::_GET_SCREEN_ACTIVE_RESOLUTION(&scrAW, &scrAH);
    if (scrAW != scrCurrActiveResW || scrAH != scrCurrActiveResH)
    {
        scrCurrActiveResW = scrAW;
        scrCurrActiveResH = scrAH;
        return true;
    }
    else
        return false;
}

void AssignTextScale()
{
    textCurrScale = (sqrtf(sqrtf((float)scrCurrActiveResW * (float)scrCurrActiveResH)) * 0.01) - ((float)scrCurrActiveResW * (float)scrCurrActiveResH * 0.00000001);
}

void DoScaleMenuProportions()
{
    int scrResW, scrResH;
    GRAPHICS::GET_SCREEN_RESOLUTION(&scrResW, &scrResH);
    
    currMenu.xS = 10.0 / (float)scrResW,
    currMenu.yS = 10.0 / (float)scrResH,
    currMenu.itemWidthS = 270.0 / (float)scrResW,
    currMenu.itemHeightS = 36.0 / (float)scrResH,
    currMenu.textItemLeftS = 20.0 / (float)scrResW,
    currMenu.textItemValueLeftS = 230.0 / (float)scrResW,
    currMenu.textTitleLeftS = 50.0 / (float)scrResW,
    currMenu.textHintLeftS = currMenu.itemWidthS + 20.0 / (float)scrResW;
}

void SetCurrMenu(MenuType aType)
{
    if (currMenu.type != aType)
        PlaySnd(sBeep);

    currMenu.type = aType;
    currMenu.activeItem = 0;
    
    switch (aType)
    {
        /*case mNone:
            currMenu.itemCount = 0;
            currMenu.startItemIndex = 0;
            currMenu.txtsIndex = -1;
            currMenu.titleType = miNormal;
            break;*/
        case mInventory:
            currMenu.itemCount = 6;
            currMenu.startItemIndex = 0;
            currMenu.txtsIndex = 0;
            currMenu.titleType = miTitleInventory;
            break;
        case mFood:
            currMenu.itemCount = 4;
            currMenu.startItemIndex = 0;
            currMenu.txtsIndex = 1;
            currMenu.titleType = miTitleBuyFood;
            break;
        case mLiquor:
            currMenu.itemCount = 2;
            currMenu.startItemIndex = 4;
            currMenu.txtsIndex = 2;
            currMenu.titleType = miTitleBuyLiquor;
            break;
    }
}

int GetPer(NeedType aNeed) {
    int res = round(dataStore.currPlayerStats.needsLevels[aNeed] / (dataStore.maxNeedsLevels[aNeed] / 100.0));

    if (res < 0) {
        return 0;
    }
    else
        return res;
}

void SetNeedStatus(NeedType aNeed) {
    __int8 st;
    int perc;
    switch (aNeed)
    {
        case nFood:
        case nSleep:
        case nFun:
            st = 5;
            perc = GetPer(aNeed);
            if (perc > 0) st = 4;
            if (perc > 5) st = 3;
            if (perc > 15) st = 2;
            if (perc > 50) st = 1;
            if (perc > 75) st = 0;
            dataStore.currPlayerStats.needsStatuses[aNeed] = st;
            if (dataStore.autosaveAllowed)
                if (abs(memNeedsPer[aNeed] - perc) >= dataStore.autosaveBy)
                {
                    memNeedsPer[aNeed] = perc;
                    SaveSettings(SaveSettingKindType(aNeed));
                }
            break;
        case nAll:
            SetNeedStatus(nFood);
            SetNeedStatus(nSleep);
            SetNeedStatus(nFun);
            break;
    }
}

void SwitchToCurrentPlayer()
{
    if (currPlayerPed_ID != PLAYER::PLAYER_PED_ID())
    {

        if (dataStore.autosaveAllowed)
            SaveSettings(sskAllNeedsLevels);

        currPlayerPed_ID = PLAYER::PLAYER_PED_ID();
        currPlayer_ID = PLAYER::PLAYER_ID();

        if (PED::IS_PED_MODEL(currPlayerPed_ID, GAMEPLAY::GET_HASH_KEY("player_zero"))) currPlayer = pMICHAEL;
        else if (PED::IS_PED_MODEL(currPlayerPed_ID, GAMEPLAY::GET_HASH_KEY("player_one"))) currPlayer = pFRANKLIN;
        else if (PED::IS_PED_MODEL(currPlayerPed_ID, GAMEPLAY::GET_HASH_KEY("player_two"))) currPlayer = pTREVOR;
        else if (PED::IS_PED_MODEL(currPlayerPed_ID, GAMEPLAY::GET_HASH_KEY("mp_f_freemode_01"))) currPlayer = pMP;
        else
            currPlayer = pUNKNOWN;

        LoadSettings(lskPlayerData);

        memNeedsPer[nFood] = GetPer(nFood);
        memNeedsPer[nSleep] = GetPer(nSleep);
        memNeedsPer[nFun] = GetPer(nFun);

        SetNeedStatus(nAll);
        SetCurrMenu(mNone);
    }
}

void ShowMsg()
{
    if (currMsgCanShow)
    {
        if (GetTickCount64() < currMsgTime)
        {
            GRAPHICS::DRAW_RECT(
                currMenu.xS + currMenu.itemWidthS,
                currMenu.yS + (currMenu.itemHeightS * (float)currMenu.itemMaxCount) + (currMenu.itemHeightS * 1.5),
                currMenu.itemWidthS * 2.0,
                currMenu.itemHeightS,
                msgColors[0][0],
                msgColors[0][1],
                msgColors[0][2],
                msgColors[0][3]);
            UI::SET_TEXT_FONT(0);
            UI::SET_TEXT_SCALE(0.0, textCurrScale);
            UI::SET_TEXT_COLOUR(msgColors[1][0], msgColors[1][1], msgColors[1][2], msgColors[1][3]);
            UI::SET_TEXT_CENTRE(0);
            UI::SET_TEXT_DROPSHADOW(0, 0, 0, 0, 0);
            UI::SET_TEXT_EDGE(0, 0, 0, 0, 0);
            UI::_SET_TEXT_ENTRY("STRING");
            UI::_ADD_TEXT_COMPONENT_STRING((char*)currMsg.c_str());
            UI::_DRAW_TEXT(currMenu.textItemLeftS, currMenu.yS + (currMenu.itemHeightS * (float)currMenu.itemMaxCount) + (currMenu.itemHeightS * 1.25));
        }
        else
            currMsgCanShow = false;
    }
}

void SetMsg(std::string aMsg, DWORD aTime = 2500)
{
    currMsg = aMsg;
    currMsgTime = GetTickCount64() + aTime;
    currMsgCanShow = true;
}

void ShowNeedsStats()
{
    if (dataStore.needsStatsBgIntensity > 0)
        GRAPHICS::DRAW_RECT(
            dataStore.needsStatsPos.x + 0.0345f,
            dataStore.needsStatsPos.y + (((0.021f * (float)dataStore.activeNeedsCount) + ((float)dataStore.activeNeedsCount * 0.0005f)) / 2.0f),
            0.074f,
            (0.021f * (float)dataStore.activeNeedsCount) + ((float)dataStore.activeNeedsCount * 0.0005f),
            playersColors[currPlayer][0],
            playersColors[currPlayer][1],
            playersColors[currPlayer][2],
            dataStore.needsStatsBgIntensity);

    hPosAdjust = 0.0;
    for (NeedType hNeed = _First; hNeed <= _Last; hNeed = NeedType(hNeed + 1))
        if (dataStore.needsEnabled[hNeed])
        {
            UI::SET_TEXT_FONT(0);
            UI::SET_TEXT_SCALE(0.0, 0.30);
            UI::SET_TEXT_COLOUR(
                needsStatsColors[dataStore.currPlayerStats.needsStatuses[hNeed]][0],
                needsStatsColors[dataStore.currPlayerStats.needsStatuses[hNeed]][1],
                needsStatsColors[dataStore.currPlayerStats.needsStatuses[hNeed]][2],
                needsStatsColors[dataStore.currPlayerStats.needsStatuses[hNeed]][3]);
            UI::SET_TEXT_WRAP(0.0, 1.0);
            UI::SET_TEXT_CENTRE(0);
            UI::SET_TEXT_DROPSHADOW(0, 0, 0, 0, 0);
            UI::SET_TEXT_EDGE(1, 0, 0, 0, 205);
            snprintf(needTxtBuffer, sizeof(needTxtBuffer), txtsNeeds[hNeed][dataStore.lIndex], GetPer(hNeed));
            UI::_SET_TEXT_ENTRY("STRING");
            UI::_ADD_TEXT_COMPONENT_STRING((char*)needTxtBuffer);
            UI::_DRAW_TEXT(dataStore.needsStatsPos.x, dataStore.needsStatsPos.y + (hPosAdjust * 0.02));
            hPosAdjust++;
        }
}

void DrawHint(char* aHint)
{
    UI::SET_TEXT_FONT(0);
    UI::SET_TEXT_SCALE(0.0, textCurrScale * 1.85);
    UI::SET_TEXT_COLOUR(255, 255, 255, 255);
    UI::SET_TEXT_WRAP(0.0, 1.0);
    UI::SET_TEXT_CENTRE(1);
    UI::SET_TEXT_DROPSHADOW(0, 0, 0, 0, 0);
    UI::SET_TEXT_EDGE(1, 0, 0, 0, 205);
    UI::_SET_TEXT_ENTRY("STRING");
    UI::_ADD_TEXT_COMPONENT_STRING(aHint);
    UI::_DRAW_TEXT(0.5, 0.95);
}

void DrawMenuItemText(char* aLabel, float aXScaled, float aYScaled, int aFont, float aScale, MenuItemType aType)
{
    UI::SET_TEXT_FONT(aFont);
    UI::SET_TEXT_SCALE(0.0, aScale);
    UI::SET_TEXT_COLOUR(menuItemColors[aType][1][0], menuItemColors[aType][1][1], menuItemColors[aType][1][2], menuItemColors[aType][1][3]);
    UI::SET_TEXT_CENTRE(0);
    UI::SET_TEXT_DROPSHADOW(0, 0, 0, 0, 0);
    UI::SET_TEXT_EDGE(0, 0, 0, 0, 0);
    UI::_SET_TEXT_ENTRY("STRING");
    UI::_ADD_TEXT_COMPONENT_STRING((char*)aLabel);
    UI::_DRAW_TEXT(aXScaled, aYScaled);
}

void DrawMenuItem(char* aLabel, std::string aMenuItemValue, float aTopScaled, MenuItemType aType)
{
    float
        textScale = textCurrScale,
        textStretch = 4.0,
        itemWidthScaled = currMenu.itemWidthS,
        textItemLeftScaled = currMenu.textItemLeftS;
    int font = 0;

    if (aType != miNormal && aType != miActive) //kdyz je title
    {
        itemWidthScaled = currMenu.itemWidthS * 2.0;
        textItemLeftScaled = currMenu.textTitleLeftS;
        textScale = textCurrScale * 1.85;
        textStretch = 8.0;
        font = 1;
    }

    if (aType == miActive)    //pri vykresleni aktivni polozky, vykresli i napovedu
    {
        GRAPHICS::DRAW_RECT(
            currMenu.xS + itemWidthScaled + (currMenu.itemWidthS / 2.0),
            currMenu.yS + currMenu.itemHeightS + ((currMenu.itemHeightS * (float)currMenu.itemMaxCount) / 2.0),
            currMenu.itemWidthS,
            currMenu.itemHeightS * (float)currMenu.itemMaxCount,
            menuItemColors[aType][0][0],
            menuItemColors[aType][0][1],
            menuItemColors[aType][0][2],
            menuItemColors[aType][0][3]);
        snprintf(menuHintBuffer, sizeof(menuHintBuffer), txtsMenuHint[currMenu.activeItem + currMenu.startItemIndex][dataStore.lIndex], dataStore.goodsPrices[currMenu.activeItem + currMenu.startItemIndex]);
        DrawMenuItemText((char*)menuHintBuffer, currMenu.textHintLeftS, (currMenu.yS + currMenu.itemHeightS + (currMenu.itemHeightS / 6.0)), font, textScale, aType);
    }

    int hR = menuItemColors[aType][0][0],
        hG = menuItemColors[aType][0][1],
        hB = menuItemColors[aType][0][2];

    if (aType == miTitleInventory)
    {
        hR = playersColors[currPlayer][0],
        hG = playersColors[currPlayer][1],
        hB = playersColors[currPlayer][2];
    }

    GRAPHICS::DRAW_RECT(
        currMenu.xS + (itemWidthScaled / 2.0),
        aTopScaled + (currMenu.itemHeightS / 2.0),
        itemWidthScaled,
        currMenu.itemHeightS,
        hR,
        hG,
        hB,
        menuItemColors[aType][0][3]);
    DrawMenuItemText(aLabel, textItemLeftScaled, aTopScaled + (currMenu.itemHeightS / textStretch), font, textScale, aType);

    if (aMenuItemValue != "")
        DrawMenuItemText((char*)aMenuItemValue.c_str(), currMenu.textItemValueLeftS, aTopScaled + (currMenu.itemHeightS / textStretch), font, textScale, aType);
}

std::string GetMenuItemValue(int aInd)
{
    /*if (currMenu.type == mInventory)
        return std::to_string(dataStore.currPlayerStats.goodsCounts[aInd]) + "x";
    else if ((currMenu.type == mFood || currMenu.type == mLiquor) && aInd < currMenu.itemCount)
        return "$" + std::to_string(goodsPrices[aInd + currMenu.startItemIndex]);
    else
        return "";*/

    if (aInd < currMenu.itemCount)
        return std::to_string(dataStore.currPlayerStats.goodsCounts[aInd + currMenu.startItemIndex]) + "/" + std::to_string(dataStore.maxCarryGoodsCount);
    else
        return "";
}

void ShowMenu()
{
    if (currMenu.type != mNone)
    {
        DrawMenuItem(txtsMenu[currMenu.txtsIndex][6][dataStore.lIndex], "", currMenu.yS, currMenu.titleType);

        for (int i = 0; i < currMenu.itemMaxCount; i++)
            if (i != currMenu.activeItem)
                DrawMenuItem(txtsMenu[currMenu.txtsIndex][dataStore.lIndex], GetMenuItemValue(i), currMenu.yS + currMenu.itemHeightS + (float(i * currMenu.itemHeightS)), miNormal);
            else
                DrawMenuItem(txtsMenu[currMenu.txtsIndex][currMenu.activeItem][dataStore.lIndex], GetMenuItemValue(currMenu.activeItem), currMenu.yS + currMenu.itemHeightS + (float(currMenu.activeItem * currMenu.itemHeightS)), miActive);

        if (IsKeyJustUp(keys.menuUp)) { currMenu.activeItem--; if (currMenu.activeItem < 0) currMenu.activeItem = currMenu.itemCount - 1; }
        if (IsKeyJustUp(keys.menuDown)) { currMenu.activeItem++; if (currMenu.activeItem > currMenu.itemCount - 1) currMenu.activeItem = 0; }
        if (IsKeyJustUp(keys.menuClose)) SetCurrMenu(mNone);
    }
}

std::string GetKeyName(DWORD virtualKey)
{
    unsigned int scanCode = MapVirtualKey(virtualKey, 0);
    char keyName[256];
    memset(keyName, 0, 256);
    bool isASCII = (virtualKey <= 32);

    if (!isASCII && virtualKey != VK_DIVIDE)
    {
        unsigned short int lPtrChar;
        BYTE keyboardState[256];
        GetKeyboardState(keyboardState);
        isASCII = ToAscii(virtualKey, scanCode, keyboardState, &lPtrChar, 1);
    }

    scanCode <<= 16;
    scanCode |= 0x1 << 25;
    if (!isASCII) scanCode |= 0x1 << 24;

    if (GetKeyNameTextA(scanCode, keyName, 256) > 0)
        return keyName;
    
    return "";
}

PointCategoryType CanSomethingObtain()
{

    if (!PED::IS_PED_IN_ANY_VEHICLE(currPlayerPed_ID, 1))
    {
        Vector3 playerPos = ENTITY::GET_ENTITY_COORDS(currPlayerPed_ID, 1);
        PointCategoryType canObt = pcNone;

        for (int ind = 0; ind <= (sizeof(actionPointsParams) / sizeof(actionPointsParams[0])) - 1; ind++)
        {

            if (GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(playerPos.x, playerPos.y, playerPos.z, actionPointsParams[ind].x, actionPointsParams[ind].y, actionPointsParams[ind].z, 1) < 0.6)
            {
                canObt = actionPointsParams[ind].type;
                break;
            }
        };

        if (canObt != pcNone)
        {
            if (PLAYER::GET_PLAYER_WANTED_LEVEL(currPlayer_ID) != 0)
            {
                if (currMenu.type == mFood || currMenu.type == mLiquor)
                    SetCurrMenu(mNone);
                DrawHint(txts[0][dataStore.lIndex]);
            }
            else
            {
                switch (canObt)
                {
                    case pcFood:
                        if (currMenu.type != mFood)
                            snprintf(hBuffer, sizeof(hBuffer), txts[1][dataStore.lIndex], GetKeyName(keys.action));
                        break;
                    case pcLiquor:
                        if (currMenu.type != mLiquor)
                            snprintf(hBuffer, sizeof(hBuffer), txts[2][dataStore.lIndex], GetKeyName(keys.action));
                        break;
                    case pcRestaurant:
                        snprintf(hBuffer, sizeof(hBuffer), txts[3][dataStore.lIndex], GetKeyName(keys.action), dataStore.goodsPrices[gLunch]);
                        break;
                    case pcMotel:
                        snprintf(hBuffer, sizeof(hBuffer), txts[4][dataStore.lIndex], GetKeyName(keys.action), dataStore.goodsPrices[gRoom]);
                        break;
                    case pcCoffee:
                        snprintf(hBuffer, sizeof(hBuffer), txts[5][dataStore.lIndex], GetKeyName(keys.action), dataStore.goodsPrices[gCoffe]);
                        break;
                    case pcFridge:
                        snprintf(hBuffer, sizeof(hBuffer), txts[6][dataStore.lIndex], GetKeyName(keys.action));
                        break;
                    default:
                        snprintf(hBuffer, sizeof(hBuffer), txts[7][dataStore.lIndex], GetKeyName(keys.action));
                        break;
                }
                DrawHint(hBuffer);
                return canObt;
            }
        }
    }

    return pcNone;
}

void PlayAnim(AnimType aWhat)
{
    if (dataStore.animAllowed)
    {
        if (!PED::IS_PED_IN_ANY_VEHICLE(currPlayerPed_ID, 1))
        {
            Hash currWpn;
            WEAPON::GET_CURRENT_PED_WEAPON(currPlayerPed_ID, &currWpn, 1);
            WEAPON::SET_CURRENT_PED_WEAPON(currPlayerPed_ID, 0xA2719263, 1);

            Vector3 pPos = ENTITY::GET_ENTITY_COORDS(currPlayerPed_ID, 1);
            Object obj = OBJECT::CREATE_OBJECT(GAMEPLAY::GET_HASH_KEY((char*)animParams[aWhat].objName.c_str()), pPos.x, pPos.y, pPos.z, 0, 0, 0);
            ENTITY::ATTACH_ENTITY_TO_ENTITY(obj, currPlayerPed_ID, PED::GET_PED_BONE_INDEX(currPlayerPed_ID, animParams[aWhat].boneID), animParams[aWhat].objX, animParams[aWhat].objY, animParams[aWhat].objZ, animParams[aWhat].objRotX, animParams[aWhat].objRotY, animParams[aWhat].objRotZ, 1, 1, 1, 1, 0, 1);

            int loopAdjuster = 0;
            if (aWhat == aSmoke)
                loopAdjuster = 1;

            for (int i = 0; i < dataStore.animLoopCount + loopAdjuster; i++)
            {
                STREAMING::REQUEST_ANIM_DICT((char*)animParams[aWhat].anim1_Dict.c_str());
                while (!STREAMING::HAS_ANIM_DICT_LOADED((char*)animParams[aWhat].anim1_Dict.c_str())) WAIT(10);
                AI::TASK_PLAY_ANIM(currPlayerPed_ID, (char*)animParams[aWhat].anim1_Dict.c_str(), (char*)animParams[aWhat].anim1_Name.c_str(), 8.0f, 1.0f, animParams[aWhat].amimTime1, 0, 0, 0, 0, 0);
                WAIT(animParams[aWhat].waitTime1);
                
                //efekt
                if (animParams[aWhat].effectPTFX != "")
                {
                    STREAMING::REQUEST_NAMED_PTFX_ASSET((char*)animParams[aWhat].effectPTFX.c_str());
                    while (!STREAMING::HAS_NAMED_PTFX_ASSET_LOADED((char*)animParams[aWhat].effectPTFX.c_str())) WAIT(10);
                    {
                        GRAPHICS::_SET_PTFX_ASSET_NEXT_CALL((char*)animParams[aWhat].effectPTFX.c_str());
                        GRAPHICS::START_PARTICLE_FX_NON_LOOPED_ON_PED_BONE((char*)animParams[aWhat].effectName.c_str(), currPlayerPed_ID, animParams[aWhat].effX, animParams[aWhat].effY, animParams[aWhat].effZ, animParams[aWhat].effRotX, animParams[aWhat].effRotY, animParams[aWhat].effRotZ, animParams[aWhat].effBoneID, 0.3f, 0, 0, 0);
                    }
                    WAIT(animParams[aWhat].waitTime2);
                }

                //sekundarni animace
                if (animParams[aWhat].anim2_Dict != "")
                {
                    STREAMING::REQUEST_ANIM_DICT((char*)animParams[aWhat].anim2_Dict.c_str());
                    while (!STREAMING::HAS_ANIM_DICT_LOADED((char*)animParams[aWhat].anim2_Dict.c_str())) WAIT(10);
                    AI::TASK_PLAY_ANIM(currPlayerPed_ID, (char*)animParams[aWhat].anim2_Dict.c_str(), (char*)animParams[aWhat].anim2_Name.c_str(), 8.0f, 1.0f, animParams[aWhat].animTime2, 0, 0, 0, 0, 0);
                    WAIT(animParams[aWhat].waitTime2);
                }
            }
            WAIT(animParams[aWhat].terminationTime);
            OBJECT::DELETE_OBJECT(&obj);
            WEAPON::SET_CURRENT_PED_WEAPON(currPlayerPed_ID, currWpn, 1);
        }
    }
}

void DrunkMode(DrunkModeStateType aState = drunkModeState)
{
    if (aState == dmsStart)
    {
        drunkTime = GetTickCount64() + 30000;
        drunkModeState = dmsProceeds;

        CAM::SHAKE_CINEMATIC_CAM("DRUNK_SHAKE", 2.0f);
        CAM::SHAKE_GAMEPLAY_CAM("DRUNK_SHAKE", 2.0f);
        CAM::SET_CAM_SHAKE_AMPLITUDE(-1, 5.0f);
        STREAMING::REQUEST_ANIM_DICT("[email protected]@slightlydrunk");
        while (!STREAMING::HAS_ANIM_DICT_LOADED("[email protected]@slightlydrunk"))
            WAIT(0);
        PED::SET_PED_MOVEMENT_CLIPSET(currPlayerPed_ID, "[email protected]@slightlydrunk", 0.75f);
        PED::SET_PED_CAN_PLAY_AMBIENT_ANIMS(currPlayerPed_ID, 0);
        PED::SET_PED_ALTERNATE_MOVEMENT_ANIM(currPlayerPed_ID, 0, "[email protected]@slightlydrunk", "idle", 2.0f, 1);
        AUDIO::SET_PED_IS_DRUNK(currPlayerPed_ID, true);
    }

    if ((aState == dmsProceeds && GetTickCount64() > drunkTime) || aState == dmsStop)
    {
        drunkModeState = dmsStopped;

        PED::RESET_PED_MOVEMENT_CLIPSET(currPlayerPed_ID, 0.0f);
        PED::CLEAR_PED_ALTERNATE_MOVEMENT_ANIM(currPlayerPed_ID, 0, 0.0f);
        CAM::SHAKE_CINEMATIC_CAM("DRUNK_SHAKE", 0.0f);
        CAM::SHAKE_GAMEPLAY_CAM("DRUNK_SHAKE", 0.0f);
        CAM::SET_CAM_SHAKE_AMPLITUDE(-1, 0.0f);
        PED::SET_PED_CAN_PLAY_AMBIENT_ANIMS(currPlayerPed_ID, 1);
        AUDIO::SET_PED_IS_DRUNK(currPlayerPed_ID, false);
    }
}

void TimeShift(DWORD aForwardHours)
{
    CAM::DO_SCREEN_FADE_OUT(2500);
    WAIT(2500);
    int hr = TIME::GET_CLOCK_HOURS();
    hr += aForwardHours;
    if (hr > 23)
    {
        hr -= 24;
        TIME::SET_CLOCK_DATE((TIME::GET_CLOCK_DAY_OF_MONTH() + 1), TIME::GET_CLOCK_MONTH(), TIME::GET_CLOCK_YEAR());
    }
    TIME::SET_CLOCK_TIME(hr, TIME::GET_CLOCK_MINUTES(), 0);
    CAM::DO_SCREEN_FADE_IN(2500);

    memHours = hr;
}

void NegativeEffects()
{
    DrunkMode();
    
    if (dataStore.needsEnabled[nFood])
    {
        if (PLAYER::IS_SPECIAL_ABILITY_ENABLED(currPlayer_ID) || ownSADisabled)
            if (dataStore.currPlayerStats.needsStatuses[nFood] > 2)
            {
                PLAYER::SPECIAL_ABILITY_DEACTIVATE(currPlayer_ID);
                PLAYER::ENABLE_SPECIAL_ABILITY(currPlayer_ID, 0);
                ownSADisabled = true;
            }
            else if (!PLAYER::IS_SPECIAL_ABILITY_ENABLED(currPlayer_ID))
            {
                PLAYER::ENABLE_SPECIAL_ABILITY(currPlayer_ID, 1);
                ownSADisabled = false;
            }
        
        if (dataStore.currPlayerStats.needsStatuses[nFood] > 3)
            PLAYER::SET_PLAYER_HEALTH_RECHARGE_MULTIPLIER(currPlayer_ID, 0);
        else if (!dataStore.needsEnabled[nSleep] || dataStore.currPlayerStats.needsStatuses[nSleep] < 4)
            PLAYER::SET_PLAYER_HEALTH_RECHARGE_MULTIPLIER(currPlayer_ID, 1);

        if (dataStore.currPlayerStats.needsStatuses[nFood] > 4)
        {
            if (GetTickCount64() > negTimerFood)
            {
                if (ENTITY::GET_ENTITY_HEALTH(currPlayerPed_ID) > 115) ENTITY::SET_ENTITY_HEALTH(currPlayerPed_ID, (ENTITY::GET_ENTITY_HEALTH(currPlayerPed_ID) - 10));
                negTimerFood = GetTickCount64() + 2000;
            }
        }
        else
            negTimerFood = GetTickCount64() + 2000;
    }

    if (dataStore.needsEnabled[nSleep])
    {
        if (dataStore.currPlayerStats.needsStatuses[nSleep] > 2)
            PLAYER::SET_PLAYER_SPRINT(currPlayer_ID, 0);
        else
            PLAYER::SET_PLAYER_SPRINT(currPlayer_ID, 1);

        if (dataStore.currPlayerStats.needsStatuses[nSleep] > 3)
            PLAYER::SET_PLAYER_HEALTH_RECHARGE_MULTIPLIER(currPlayer_ID, 0);
        else if (!dataStore.needsEnabled[nFood] || dataStore.currPlayerStats.needsStatuses[nFood] < 4)
            PLAYER::SET_PLAYER_HEALTH_RECHARGE_MULTIPLIER(currPlayer_ID, 1);

        if (dataStore.currPlayerStats.needsStatuses[nSleep] > 4)
        {
            if (!jumpDone && !PED::IS_PED_JUMPING(currPlayerPed_ID) && !PED::IS_PED_CLIMBING(currPlayerPed_ID)) jumpDone = true;

            if ((PED::IS_PED_JUMPING(currPlayerPed_ID) || PED::IS_PED_CLIMBING(currPlayerPed_ID)) && jumpDone)
            {
                ENTITY::SET_ENTITY_HEALTH(currPlayerPed_ID, (ENTITY::GET_ENTITY_HEALTH(currPlayerPed_ID) - 15));
                jumpDone = false;
            }
        }
    }

    if (dataStore.needsEnabled[nFun])
    {
        if (dataStore.currPlayerStats.needsStatuses[nFun] > 2)
        {
            int hDown;
            if (dataStore.currPlayerStats.needsStatuses[nFun] > 3)
                hDown = 30;
            else
                hDown = 15;

            if (ENTITY::GET_ENTITY_HEALTH(currPlayerPed_ID) > (ENTITY::GET_ENTITY_MAX_HEALTH(currPlayerPed_ID) - hDown) && !CAM::IS_SCREEN_FADED_OUT() && !CAM::IS_SCREEN_FADING_IN() && !CAM::IS_SCREEN_FADING_OUT())
            {
                ENTITY::SET_ENTITY_HEALTH(currPlayerPed_ID, (ENTITY::GET_ENTITY_MAX_HEALTH(currPlayerPed_ID) - hDown));
            }
        }
    }
}

bool Pay(int aValue)
{
    char stMoney[32];
    sprintf_s(stMoney, "SP%d_TOTAL_CASH", currPlayer);
    int currMoney;
    STATS::STAT_GET_INT(GAMEPLAY::GET_HASH_KEY(stMoney), &currMoney, -1);
    if (currMoney >= aValue)
    {
        currMoney -= aValue;
        STATS::STAT_SET_INT(GAMEPLAY::GET_HASH_KEY(stMoney), currMoney, 1);
        return true;
    }
    else
    {
        SetMsg(txts[9][dataStore.lIndex]);
        return false;
    }    
}

void AddToNeed(NeedType aWhat, unsigned __int8 aMinPerc, unsigned __int8 aMaxPerc, bool asNegative = false)
{
    if (dataStore.needsEnabled[aWhat])
    {
        int    min = (int)round(((float)dataStore.maxNeedsLevels[aWhat] / 100.0) * (float)aMinPerc),
            max = (int)round(((float)dataStore.maxNeedsLevels[aWhat] / 100.0) * (float)aMaxPerc);

        int result = (min + (rand() % (int)(max - min + 1)));

        if (asNegative)
            result = result * -1;

        dataStore.currPlayerStats.needsLevels[aWhat] += result;

        if (dataStore.currPlayerStats.needsLevels[aWhat] > dataStore.maxNeedsLevels[aWhat])
            dataStore.currPlayerStats.needsLevels[aWhat] = dataStore.maxNeedsLevels[aWhat];
        else if (dataStore.currPlayerStats.needsLevels[aWhat] < 0)
            dataStore.currPlayerStats.needsLevels[aWhat] = 0;

        SetNeedStatus(NeedType(aWhat));
    }
}

void AddHealth(__int8 aValue)
{
    int newValue = ENTITY::GET_ENTITY_HEALTH(currPlayerPed_ID) + aValue;
    ENTITY::SET_ENTITY_HEALTH(currPlayerPed_ID, newValue);
}

void Consume(GoodsType aWhat)
{
    switch (aWhat)
    {
        case gPnQ:
            AddHealth(10);
            AddToNeed(nFood, 10, 20);
            break;
        case gEgo:
            AddHealth(20);
            AddToNeed(nFood, 20, 30);
            break;
        case gMet:
            AddHealth(30);
            AddToNeed(nFood, 30, 50);
            break;
        case gCola:
            AddHealth(25);
            AddToNeed(nFood, 5, 15);
            break;
        case gBeer:
            AddHealth(-3);
            AddToNeed(nSleep, 7, 7, true);
            AddToNeed(nFun, 25, 25);
            DrunkMode(dmsStart);
            break;
        case gCigarette:
            AddHealth(-8);
            AddToNeed(nSleep, 2, 2, true);
            AddToNeed(nFun, 100, 100);
            break;
    }
}

void UseOrBuyGoods()
{
    if (currMenu.type != mNone)
        if (IsKeyJustUp(keys.menuAction))
        {
            switch (currMenu.type)
            {
                case mFood:
                case mLiquor:
                    goodsItem = GoodsType(currMenu.activeItem + currMenu.startItemIndex);
                    bundle = 1;
                    if (goodsItem == gCigarette)
                        bundle = 5;

                    if (dataStore.currPlayerStats.goodsCounts[goodsItem] < dataStore.maxCarryGoodsCount)
                    {
                        if (Pay(dataStore.goodsPrices[goodsItem]))
                        {
                            dataStore.currPlayerStats.goodsCounts[goodsItem] += bundle;
                            PlaySnd(sDelete);
                            if (dataStore.autosaveAllowed)
                                SaveSettings(sskGoods);
                        }
                    }
                    else
                        SetMsg(txts[8][dataStore.lIndex]);
                    break;
                case mInventory:
                    if (dataStore.currPlayerStats.goodsCounts[currMenu.activeItem] > 0)
                    {
                        dataStore.currPlayerStats.goodsCounts[currMenu.activeItem]--;
                        PlaySnd(sDelete);
                        PlayAnim(AnimType(currMenu.activeItem));
                        Consume(GoodsType(currMenu.activeItem));
                        if (dataStore.autosaveAllowed)
                            SaveSettings(sskGoods);
                    }
                    else
                        SetMsg(txts[10][dataStore.lIndex]);
                    break;
            }

        }
}

void DropNeeds()
{
    if (GetTickCount64() > needsTimer)
    {
        for (unsigned __int8 hNeed = _First; hNeed <= _Last; hNeed++)
            if (dataStore.needsEnabled[hNeed])
                if (dataStore.currPlayerStats.needsLevels[hNeed] > 0)
                {
                    dataStore.currPlayerStats.needsLevels[hNeed]--;
                    SetNeedStatus(NeedType(hNeed));
                }
        needsTimer = GetTickCount64() + dataStore.needsTimerTime;
    }
}

void WhenPlayerIsDead()
{
    if (PLAYER::IS_PLAYER_DEAD(currPlayer_ID))
    {
        DrunkMode(dmsStop);
        SetCurrMenu(mNone);
    }
}

void DrawActionMarks()
{
    for (int ind = 0; ind <= (sizeof(actionPointsParams) / sizeof(actionPointsParams[0])) - 1; ind++)
    {
        GRAPHICS::DRAW_MARKER(2, actionPointsParams[ind].x, actionPointsParams[ind].y, actionPointsParams[ind].z, 0.0f, 0.0f, 0.0f, 180.0f, 0.0f, 0.0f, 0.75f, 0.75f, 0.75f,
            actionPointColor[actionPointsParams[ind].type][0],
            actionPointColor[actionPointsParams[ind].type][1],
            actionPointColor[actionPointsParams[ind].type][2],
            125, false, true, 2, false, false, false, false);
    }
}

void ShowBlipsOnMap()
{
    Blip blip;
    for (int ind = 0; ind <= (sizeof(actionPointsParams) / sizeof(actionPointsParams[0])) - 1; ind++)
    {
        if (actionPointsParams[ind].sprite > 0 && dataStore.showBlips[actionPointsParams[ind].type])
        {
            blip = UI::ADD_BLIP_FOR_COORD(actionPointsParams[ind].x, actionPointsParams[ind].y, actionPointsParams[ind].z);
            UI::SET_BLIP_SPRITE(blip, actionPointsParams[ind].sprite);
            UI::SET_BLIP_SCALE(blip, 1);
            UI::SET_BLIP_COLOUR(blip, actionPointsParams[ind].color);

            
            UI::_ADD_TEXT_COMPONENT_STRING(txtsBlipsNames[actionPointsParams[ind].type][dataStore.lIndex]);
            

            UI::SET_BLIP_AS_SHORT_RANGE(blip, true);
        }
    }
}

#ifdef TestMode
void TestProc()
{
    if (IsKeyJustUp(VK_NUMPAD7))
        if (dataStore.lIndex == 0)
            dataStore.lIndex = 1;
        else
            dataStore.lIndex = 0;

    if (IsKeyJustUp(VK_NUMPAD9))
    {
        Vector3 ps = ENTITY::GET_ENTITY_COORDS(currPlayerPed_ID, 1);
        std::string st = "X: " + std::to_string(ps.x) + "  Y: " + std::to_string(ps.y) + "  Z: " + std::to_string(ps.z);
        SetMsg(st, 15000);
    }

    if (IsKeyJustUp(VK_NUMPAD4))
    {
        testType += 1;
        if (testType > 4)
            testType = 0;

        switch (testType)
        {
            case 0:
                SetMsg("Jidlo");
                break;
            case 1:
                SetMsg("Spanek");
                break;
            case 2:
                SetMsg("Zabava");
                break;
            case 3:
                SetMsg("Penize");
                break;
            case 4:
                SetMsg("Zdravi");
                break;
        }
    }

    if (IsKeyJustUp(VK_NUMPAD1))
    {
        switch (testType)
        {
            case 0:
                AddToNeed(nFood, 1, 1, true);
                break;
            case 1:
                AddToNeed(nSleep, 1, 1, true);
                break;
            case 2:
                AddToNeed(nFun, 1, 1, true);
                break;
            case 3:
                char pM[32];
                sprintf_s(pM, "SP%d_TOTAL_CASH", currPlayer);
                STATS::STAT_SET_INT(GAMEPLAY::GET_HASH_KEY(pM), 0, 1);
                break;
            case 4:
                ENTITY::SET_ENTITY_HEALTH(currPlayerPed_ID, ENTITY::GET_ENTITY_HEALTH(currPlayerPed_ID) - 1);
                break;
        }
    }

    if (IsKeyJustUp(VK_NUMPAD3))
    {
        switch (testType)
        {
            case 0:
                AddToNeed(nFood, 1, 1);
                break;
            case 1:
                AddToNeed(nSleep, 1, 1);
                break;
            case 2:
                AddToNeed(nFun, 1, 1);
                break;
            case 3:
                char pM[32];
                sprintf_s(pM, "SP%d_TOTAL_CASH", currPlayer);
                STATS::STAT_SET_INT(GAMEPLAY::GET_HASH_KEY(pM), 400, 1);
                break;
            case 4:
                ENTITY::SET_ENTITY_HEALTH(currPlayerPed_ID, ENTITY::GET_ENTITY_HEALTH(currPlayerPed_ID) + 1);
                break;
        }
    }

    UI::SET_TEXT_FONT(0);
    UI::SET_TEXT_SCALE(0.0, 0.30);
    UI::SET_TEXT_COLOUR(163, 73, 164, 255);
    UI::SET_TEXT_WRAP(0.0, 1.0);
    UI::SET_TEXT_CENTRE(0);
    UI::SET_TEXT_DROPSHADOW(0, 0, 0, 0, 0);
    UI::SET_TEXT_EDGE(1, 0, 0, 0, 205);
    UI::_SET_TEXT_ENTRY("STRING");
    UI::_ADD_TEXT_COMPONENT_STRING((char *)std::to_string(ENTITY::GET_ENTITY_HEALTH(currPlayerPed_ID)).c_str());
    UI::_DRAW_TEXT(dataStore.needsStatsPos.x, dataStore.needsStatsPos.y - 0.02);

}
#endif

void Main()
{
    srand(GetTickCount64());

    LoadSettings(lskOptions);
    DoScaleMenuProportions();    //nepocita z aktivniho rozliseni -> neni nutny rescale pri zmene rozliseni, jako u textu
    ShowBlipsOnMap();

    while (true)    //pozastaveni do nacteni hry
    {
        if (CAM::IS_SCREEN_FADED_OUT())
            break;
        WAIT(0);
    }
        
    memHours = TIME::GET_CLOCK_HOURS();

    while (true)
    {
        #ifdef TestMode
        TestProc();
        #endif

        if (ActiveResChanged())
            AssignTextScale();

        SwitchToCurrentPlayer();
        if (currPlayer != pUNKNOWN)
        {
            WhenPlayerIsDead();
            DrawActionMarks();
            
            switch (CanSomethingObtain())
            {
                case pcFood:
                    if (IsKeyJustUp(keys.action))
                        SetCurrMenu(mFood);
                    break;
                case pcLiquor:
                    if (IsKeyJustUp(keys.action))
                        SetCurrMenu(mLiquor);
                    break;
                case pcCoffee:
                    if (IsKeyJustUp(keys.action))
                        if (Pay(dataStore.goodsPrices[gCoffe]))
                        {
                            TimeShift(1);
                            PlayAnim(aDrinkCoffee);
                            AddToNeed(nFood, 5, 10);
                            AddToNeed(nSleep, 10, 20);
                            AddToNeed(nFun, 100, 100);
                            AddHealth(40);
                        }
                    break;
                case pcRestaurant:
                    if (IsKeyJustUp(keys.action))
                        if (Pay(dataStore.goodsPrices[gLunch]))
                        {
                            TimeShift(1);
                            AddToNeed(nFood, 100, 100);
                            AddToNeed(nFun, 100, 100);
                            AddHealth(100);
                        }
                    break;
                case pcMotel:
                    if (IsKeyJustUp(keys.action))
                        if (Pay(dataStore.goodsPrices[gRoom]))
                        {
                            TimeShift(7);
                            AddToNeed(nFood, 5, 10, true);
                            AddToNeed(nSleep, 100, 100);
                            AddToNeed(nFun, 25, 50);
                            AddHealth(100);
                        }
                    break;
                case pcFridge:
                    if (IsKeyJustUp(keys.action))
                        {
                            TimeShift(1);
                            AddToNeed(nFood, 100, 100);
                            AddHealth(100);
                        }
                    break;
                default:
                    if (currMenu.type == mFood || currMenu.type == mLiquor)
                        SetCurrMenu(mNone);

                    currHours = TIME::GET_CLOCK_HOURS();
                    if (memHours != currHours)
                    {
                        if (((((currHours - memHours) == 6 || (currHours - memHours) == -18) && currPlayer == pMICHAEL) ||
                            (((currHours - memHours) == 8 || (currHours - memHours) == -16) && currPlayer == pFRANKLIN) ||
                            (((currHours - memHours) == 12 || (currHours - memHours) == -12) && currPlayer == pTREVOR)) ||
                            (((currHours - memHours) == 8 || (currHours - memHours) == -16) && currPlayer == pMP))
                            PLAYER::CAN_PLAYER_START_MISSION(currPlayer_ID);
                        {
                            AddToNeed(nFood, 5, 10, true);
                            AddToNeed(nSleep, 100, 100);
                            AddHealth(100);
                        }
                        memHours = currHours;
                    }
                    break;
            }
            
            if (GAMEPLAY::IS_MINIGAME_IN_PROGRESS())
                AddToNeed(nFun, 100, 100);

            if (IsKeyJustUp(keys.inv))
                if (currMenu.type == mInventory)
                    SetCurrMenu(mNone);
                else
                    SetCurrMenu(mInventory);

            ShowMenu();
            UseOrBuyGoods();
            ShowMsg();
            DropNeeds();

            if (IsKeyJustUp(keys.needsStatsDisplaySwitch))
                dataStore.showNeedsStats = !dataStore.showNeedsStats;

            if (!UI::IS_RADAR_HIDDEN() && !CUTSCENE::IS_CUTSCENE_PLAYING() && !STREAMING::IS_PLAYER_SWITCH_IN_PROGRESS() && (dataStore.showNeedsStats || currMenu.type != mNone))    //_0xD9D2CFFF49FAB35F() - probiha prepnuti hrace?
                ShowNeedsStats();

            NegativeEffects();

            if ((IsKeyDown(keys.saveDataCmb) || keys.saveDataCmb == 0) && IsKeyDown(keys.saveData))
            {
                if (!keysPressed)
                {
                    keysPressed = true;
                    SaveSettings(sskAllNeedsLevels);
                    SaveSettings(sskGoods);
                    SetMsg(txts[11][dataStore.lIndex]);
                }
            }
            else
                keysPressed = false;

            if ((IsKeyDown(keys.loadDataCmb) || keys.loadDataCmb == 0) && IsKeyDown(keys.loadData))
            {
                if (!keysPressed)
                {
                    keysPressed = true;
                    LoadSettings(lskPlayerData);
                    SetMsg(txts[12][dataStore.lIndex]);
                }
            }
            else
                keysPressed = false;

            if ((IsKeyDown(keys.resetNeedsCmb) || keys.resetNeedsCmb == 0) && IsKeyDown(keys.resetNeeds))
            {
                if (!keysPressed)
                {
                    keysPressed = true;
                    AddToNeed(nFood, 100, 100);
                    AddToNeed(nSleep, 100, 100);
                    AddToNeed(nFun, 100, 100);
                    SetMsg(txts[13][dataStore.lIndex]);
                }
            }
            else
                keysPressed = false;
        }
        WAIT(0); //predava rizeni
    }
}

void ScriptMain()
{
}

 

 

What i did ;

-Used nativetrainer as template

-Edited the mod properly according to what i want.
-Fixed the errors i got.
-Added all headers (#include) to project.

My only guess about this situation is i missed headers but i checked , everything is included in it based on source code.So I would be very happy if someone helps.

Edited by Eeklynt
Link to comment
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now
 Share

  • 1 User Currently Viewing
    0 members, 0 Anonymous, 1 Guest

×
×
  • Create New...

Important Information

By using GTAForums.com, you agree to our Terms of Use and Privacy Policy.