Edditing Mod ( Need help from C++ experts )

December 1, 2020

Hey all , i want to edit this mod ; https://www.gta5-mods.com/scripts/human-needs-marcs742 to support mp male-female characters.Can anyone guide me thought for this ? There is source code which i have looked into it so it should not be hard to do it.

Edited December 1, 2020 by Eeklynt

December 2, 2020

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 December 2, 2020 by Eeklynt

December 3, 2020

here is the whole project if anyone wanna look into it; https://pixeldrain.com/u/Y8HTu1aT

edit : fixed the link.

Edited December 3, 2020 by Eeklynt

Edditing Mod ( Need help from C++ experts )

Recommended Posts

Eeklynt 0

Link to post

Share on other sites

Eeklynt 0

Link to post

Share on other sites

Eeklynt 0

Link to post

Share on other sites

Create an account or sign in to comment

Create an account

Sign in

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

Important Information

1 User Currently Viewing

0 members, 0 Anonymous, 1 Guest