define <trigger gg_trg_FICS_Core = null>;

library Core initializer Init
{

       include "cj_types_priv.j";

       define
       {
           private minBound = -2147483647
           private maxBound = 2147483647
           <dbg>(s) = BJDebugMsg(s)
       };

       private constant hashtable hash = InitHashtable();
       private int itemIndex = -2147483647;
       private int recipeIndex = 1;
       private bool isLastItemPicked = true;
          
//                    Aditional functions                            //

       private void SimError (player p, string msg)
       {
           sound s = CreateSoundFromLabel("InterfaceError",false,false,false,10,10);
           if GetLocalPlayer() == p
           {
               ClearTextMessages();
               DisplayTimedTextToPlayer(p,.52,-1.,2.,"|cffffcc00"+msg+"|r");
               StartSound(s);
               KillSoundWhenDone(s);
           };
           flush locals;
       };
          
       private string B2S(bool b)
       {
           if b
           {
               return "true";
           else
               return "false";
           };
       };

       private int getNormalItemType(int dummy)
       {
           for(int i=minBound;i<itemIndex;i++)
           {
               if LoadInteger(hash, i, 0) == dummy
               {
                   return LoadInteger(hash, i, 1)
               };
           };
           return 0;
       };
          
       private int getDefaultCharges(int dummy)
       {
           for(int i=minBound;i<itemIndex;i++)
           {
               if LoadInteger(hash, i, 0) == dummy
               {
                   return LoadInteger(hash, i, 2)
               };
           };
           return 0;
       };
          
       private int getDummyItemType(int normal)
       {
           for(int i=minBound;i<itemIndex;i++)
           {
               if LoadInteger(hash, i, 1) == normal
               {
                   return LoadInteger(hash, i, 0)
               };
           };
           return 0;
       };
          
       private bool haveEmptySlot(unit u)
       {
           for(int i=0;i<=5;i++)
           {
               if UnitItemInSlot(u, i) == null {return true};
           };
           return false;
       };
          
       private int recipeGetComponent(int recipe)
       {
           for(int i=0;i<=recipeIndex;i++)
           {
               if LoadInteger(hash, i, 0) == recipe {return LoadInteger(hash, i, 1)};
           };
           return 0;
       };
          
       private int recipeGetCount(int recipe)
       {
           for(int i=0;i<=recipeIndex;i++)
           {
               if LoadInteger(hash, i, 0) == recipe {return LoadInteger(hash, i, 2)};
           };
           return 0;
       };
          
       private int recipeGetFullItem(int recipe)
       {
           for(int i=0;i<=recipeIndex;i++)
           {
               if LoadInteger(hash, i, 0) == recipe {return LoadInteger(hash, i, 3)};
           };
           return 0;
       };
          
       private bool isItemRecipe(int id)
       {
           for(int i=0;i<=recipeIndex;i++)
           {
               if id == LoadInteger(hash, i, 0) {return true};
           };
           return false;
       };
          
       private bool isItemNormal(int id)
       {
           for(int i=minBound;i<=itemIndex;i++)
           {
               if id == LoadInteger(hash, i, 1) {return true};
           };
           return false;
       };
          
       private bool isRecipeOnetype(int recipe)
       {
           for(int i=0;i<=recipeIndex;i++)
           {
               if recipe == LoadInteger(hash, i, 0) {return LoadBoolean(hash, i, -1)};
           };
           return false;
       };
          
       private bool isItemComponent(int component)
       {
           for(int i=0;i<=recipeIndex;i++)
           {
               if LoadBoolean(hash, i, -1) && LoadInteger(hash, i, 1) == component {return true};
           };
           return false;
       };
          
       private bool isRecipeSaved(int recipe)
       {
           for(int i=0;i<=recipeIndex;i++)
           {
               if LoadInteger(hash, i, 0) == recipe {return true};
           };
           return false;
       };
          
       private bool isItemSaved(int it)
       {
           for(int i=minBound;i<=itemIndex;i++)
           {
               if LoadInteger(hash, i, 0) == it {return true};
           };
           return false;
       };
          
       private bool isRecipeCompleted(unit u, int recipe, bool empty)
       {
           int component = recipeGetComponent(recipe), count = recipeGetCount(recipe), full = recipeGetFullItem(recipe), curCount = 0;
           for(int i=0;i<6;i++)
           {
               if GetItemTypeId(UnitItemInSlot(u, i)) == component {curCount++};
           };
           if !empty && !isLastItemPicked && curCount == count - 1 {curCount++};
           flush locals;
           return curCount == count
       };
          
//                    Main functions                            //
          
       private bool modifyCharges(unit u, int id, int startCharges, bool empty)
       {
           item it, t;
           int charges = 0;
           if startCharges > 0
           {
               t = CreateItem(id, GetWidgetX(u), GetWidgetY(u));
               for(int i=0;i<=5;i++)
               {
                   it = UnitItemInSlot(u, i);
                   if GetItemTypeId(it) == id {charges += GetItemCharges(it); RemoveItem(it)};
               };
               SetItemCharges(t, charges);
               if !empty {SetItemCharges(t, charges+startCharges)};
               UnitAddItem(u, t);
           };
           flush locals;
           if charges > 0 {return true};
           return false;
       };
          
       private void saveItem(int dummy, int normal, int defaultCharges)
       {
           if !isItemSaved(dummy) && itemIndex < 0
           {
               SaveInteger(hash, itemIndex, 0, dummy);
               SaveInteger(hash, itemIndex, 1, normal);
               SaveInteger(hash, itemIndex, 2, defaultCharges);
               itemIndex++;
           };
       };
          
       private void saveOnetypeRecipe(int recipe, int component, int count, int full)
       {
           if !isRecipeSaved(recipe) && recipeIndex <= maxBound
           {
               SaveBoolean(hash, recipeIndex, -1, true);
               SaveInteger(hash, recipeIndex, 0, recipe);
               SaveInteger(hash, recipeIndex, 1, component);
               SaveInteger(hash, recipeIndex, 2, count);
               SaveInteger(hash, recipeIndex, 3, full);
               recipeIndex++;
           };
       };
          
       private void makeOnetypeRecipe(unit u, int recipe)
       {
           int component = recipeGetComponent(recipe), full = recipeGetFullItem(recipe);
           item t;
           for(int i=0;i<6;i++)
           {
               t = UnitItemInSlot(u, i);
               if GetItemTypeId(t) == component {RemoveItem(t)};
           };
           UnitAddItemById(u, full);
           DestroyEffect(AddSpecialEffect("Abilities\\Spells\\Items\\AIam\\AIamTarget.mdl", GetWidgetX(u), GetWidgetY(u)));
           flush locals;
       };
          
       private void InitDatabase()
       {
           saveItem('I000', 'rat6', 0);
           saveItem('I002', 'clfm', 0);
           saveItem('I003', 'clsd', 0);
           saveItem('I004', 'pghe', 5);
           saveItem('I005', 'pgma', 10);
           saveOnetypeRecipe('rat6', 'rat6', 5, 'ratc');
       };
          
       private bool Act()
       {
           unit u = GetTriggerUnit();
           int id = GetItemTypeId(GetManipulatedItem()), normal = getNormalItemType(id);
           bool empty = haveEmptySlot(u);
           isLastItemPicked = isItemNormal(id);
           DisableTrigger(GetTriggeringTrigger());
           if empty {UnitAddItemById(u, normal)};
           if isItemNormal(id) && isItemComponent(id) && isRecipeCompleted(u, id, empty)
           {
               makeOnetypeRecipe(u, id);
           elseif isItemNormal(id)
               modifyCharges(u, id, getDefaultCharges(getDummyItemType(id)), empty);
           elseif isItemComponent(normal) && isRecipeCompleted(u, normal, empty)
               makeOnetypeRecipe(u, normal)
           elseif !isItemComponent(normal)
               modifyCharges(u, normal, getDefaultCharges(id), empty);
           elseif !empty
               CreateItem(normal, GetWidgetX(u), GetWidgetY(u));
               SimError(GetTriggerPlayer(), "Inventory is full.");
           };
           EnableTrigger(GetTriggeringTrigger());
           flush locals;
           return false;
       };
          
       private void Init()
       {
           trigger t = CreateTrigger();
           for(int i=0;i<12;i++)
           {
               TriggerRegisterPlayerUnitEvent(t, Player(i), EVENT_PLAYER_UNIT_PICKUP_ITEM, null);
           };
           InitDatabase();
           TriggerAddCondition(t, Condition(function Act));
           flush locals;
           dbg("5 когтей для сборки рецепта\nКучу бутылок для теста сложения зарядов.\nВсе работает даже при полном инвентаре");
       };
          
};