RecipeBase.c

Go to the documentation of this file.

const int MAX_NUMBER_OF_INGREDIENTS = 2;
const int MAXIMUM_RESULTS = 10;
const float DEFAULT_SPAWN_DISTANCE = 0.5;
class RecipeBase
{
    string m_ItemsToCreate[MAXIMUM_RESULTS];
    ref array<string> m_Ingredients[MAX_NUMBER_OF_INGREDIENTS];
    ref array<string> m_SoundCategories[MAX_NUMBER_OF_INGREDIENTS];
    
    ItemBase m_Items[MAX_NUMBER_OF_INGREDIENTS];
    
    ItemBase m_IngredientsSorted[MAX_NUMBER_OF_INGREDIENTS]; //if the recipe is valid, this array will contain all ingredients sorted against the recipe ingredients
    
    //ref array<string> m_ItemsToCreate;
    
    //string m_Result;
    ref array<ItemBase> m_IngredientsToBeDeleted = new array<ItemBase>;
    string m_Name;
    
    int m_ID;
    int m_NumberOfResults;
    float m_AnimationLength = 1;//animation length in relative time units
    float m_Specialty = 0;// value > 0 for roughness, value < 0 for precision
    bool m_IsInstaRecipe;//should this recipe be performed instantly without animation
    //bool m_IsActionType;//will this recipe be also a user action(only set true if you know what you are doing)
    bool m_AnywhereInInventory;//is this recipe valid even when neither of the items is in hands
    //array<string> ptr;
 
    float m_MinQuantityIngredient[MAX_NUMBER_OF_INGREDIENTS];
    float m_MaxQuantityIngredient[MAX_NUMBER_OF_INGREDIENTS];
    float m_MinDamageIngredient[MAX_NUMBER_OF_INGREDIENTS];
    float m_MaxDamageIngredient[MAX_NUMBER_OF_INGREDIENTS];
 
    bool m_IngredientUseSoftSkills[MAX_NUMBER_OF_INGREDIENTS];
    float m_IngredientAddHealth[MAX_NUMBER_OF_INGREDIENTS];
    float m_IngredientAddQuantity[MAX_NUMBER_OF_INGREDIENTS];
    float m_IngredientSetHealth[MAX_NUMBER_OF_INGREDIENTS];
    bool m_IngredientDestroy[MAX_NUMBER_OF_INGREDIENTS];
    
    
    bool m_ResultSetFullQuantity[MAXIMUM_RESULTS];
    float m_ResultSetQuantity[MAXIMUM_RESULTS];
    float m_ResultSetHealth[MAXIMUM_RESULTS];
    float m_ResultSpawnDistance[MAXIMUM_RESULTS];
    int m_ResultToInventory[MAXIMUM_RESULTS];
    int m_ResultInheritsHealth[MAXIMUM_RESULTS];
    int m_ResultInheritsColor[MAXIMUM_RESULTS];
    int m_ResultReplacesIngredient[MAXIMUM_RESULTS];
    bool m_ResultUseSoftSkills[MAXIMUM_RESULTS];
    
    
 
    void RecipeBase()
    {
 
        for(int i = 0; i < MAX_NUMBER_OF_INGREDIENTS; i++)
        {
            m_Ingredients[i] = new array<string>;
            m_SoundCategories[i] = new array<string>;
            m_IngredientsSorted[i] = NULL;
        }
        
        for(i = 0; i < MAXIMUM_RESULTS; i++)
        {
            m_ResultSpawnDistance[i] = DEFAULT_SPAWN_DISTANCE;
        }
 
        m_NumberOfResults = 0;
        //m_IsActionType = false;
        
        m_Name = "RecipeBase default name";
        Init();
    }
 
    void Init();
 
    float GetLengthInSecs()
    {
        return m_AnimationLength * CRAFTING_TIME_UNIT_SIZE;
    }
    
    float GetSpecialty()
    {
        return m_Specialty;
    }
    
    bool IsRecipeAnywhere()
    {
        return m_AnywhereInInventory;       
    }
    
    bool CheckIngredientMatch(ItemBase item1, ItemBase item2)
    {
        if( item1 == NULL || item2 == NULL ) return false;
        
        m_Items[0] = item1;
        m_Items[1] = item2;
        
        bool found = false;
        for(int i = 0; i < MAX_NUMBER_OF_INGREDIENTS; i++)//all ingredients
        {
            found = false;
            array<string> tempArray = m_Ingredients[i];
            for(int x = 0; x < tempArray.Count(); x++)//particular ingredient array
            {
                for(int z = 0; z < MAX_NUMBER_OF_INGREDIENTS; z++)
                {
                    if( m_Items[z] != NULL )
                    {
                        ItemBase item = m_Items[z];
                        if( tempArray.Get(x) == item.GetType() || GetGame().IsKindOf(item.GetType(),tempArray.Get(x)))
                        {
                            found = true;//we found a match
                            //m_IngredientsSorted.Insert(item);
                            m_IngredientsSorted[i] = item;
                            m_Items[z] = NULL;
                        }
                    }
                    if(found) break;//we found a match, no need to check the remaining ingredients
                }
                if(found) break;//we found a match, no need to check this m_Ingredient array
            }
            if(!found) return false;// no match within an m_Ingredient array, no reason to continue the search, recipe is invalid
        }
        if(found)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
 
    void InsertIngredient(int index, string ingredient)
    {
        InsertIngredientEx(index, ingredient, "");
    }
    
    void InsertIngredientEx(int index, string ingredient, string soundCategory)
    {
        array<string> ptr = m_Ingredients[index];
        ptr.Insert(ingredient);
        m_SoundCategories[index].Insert(soundCategory);
    }
    
    void RemoveIngredient(int index, string ingredient)
    {
        array<string> ptr = m_Ingredients[index];
        for(int i = 0; i < ptr.Count(); i++)
        {
            if(ptr[i] == ingredient)
            {
                ptr.Remove(i);
                m_SoundCategories[index].Remove(i);
                return;
            }
        }
    }
 
 
    void AddResult(string item)
    {
        m_ItemsToCreate[m_NumberOfResults] = item;
        m_NumberOfResults++;
    }
 
    string GetName()
    {
        return m_Name;
    }
 
    bool IsInstaRecipe()
    {
        return m_IsInstaRecipe;
    }
    
    
 
    //spawns results in the world
    void SpawnItems(ItemBase ingredients[], PlayerBase player, array<ItemBase> spawned_objects/*out*/)
    {
        //vector item_position = player.GetPosition() + ( player.GetDirection() * 1 );
        //Debug.Log("SpawnItems called","recipes");
        spawned_objects.Clear();//just to make sure
        EntityAI object = NULL;
        
        for(int i = 0; i < m_NumberOfResults; i++)
        {
            string item_to_spawn = m_ItemsToCreate[i];
            
            if( m_ResultInheritsColor[i] != -1 )
            {
                ItemBase item = ingredients[m_ResultInheritsColor[i]];
                //string class_name = item.GetType();
                string color = item.ConfigGetString("color");
                string new_class_name = m_ItemsToCreate[i] + color;
                item_to_spawn = new_class_name;
            }
            
            if( m_ResultToInventory[i] == -1 ) 
            {
                Debug.Log("  = "+m_ResultToInventory[i].ToString(),"recipes");
                /*
                InventoryLocation inv_loc = new InventoryLocation;
                if (player.GetInventory().FindFirstFreeLocationForNewEntity(item_to_spawn, FindInventoryLocationType.ANY, inv_loc))
                {
                    object = SpawnItemOnLocation(item_to_spawn, inv_loc, false);
                }
                */
                object = player.GetInventory().CreateInInventory(item_to_spawn);
            }
            else if (m_ResultToInventory[i] >= 0)
            {
                /*
                object = player.SpawnEntityOnGroundOnCursorDir(item_to_spawn, 0.5);
 
                ItemBase item_swap_with = ingredients[m_ResultToInventory[i]];
                player.SwapEntities(true, item_swap_with, EntityAI.Cast(object));
                */
            }
            else if ( m_ResultToInventory[i] == -2 )
            {
                object = player.GetInventory().CreateEntityInCargo(item_to_spawn);
            }
            if( !object )
            {
                //spawning in inventory failed, spawning on the ground instead.....
                object = player.SpawnEntityOnGroundOnCursorDir(item_to_spawn, m_ResultSpawnDistance[i]);
                if( !object)
                {
                    Error("failed to spawn entity "+item_to_spawn+" , make sure the classname exists and item can be spawned");
                }
            }
            spawned_objects.Insert(ItemBase.Cast(object));
            //Debug.Log("spawning item "+item_to_spawn,"recipes");
            object = null;
        }
 
    }
 
    //applies final modifications to results
    void ApplyModificationsResults(ItemBase sorted[], array<ItemBase> results, ItemBase result, PlayerBase player)
    {
        float all_ingredients_health = 0;//this is used later in results
        float all_ingredients_health01 = 0;//combined damage % of ingredients
        int value_delta;
        for(int i = 0; i < MAX_NUMBER_OF_INGREDIENTS; i++)
        {
            ItemBase ingrd = ItemBase.Cast(sorted[i]);
            all_ingredients_health += ingrd.GetHealth("", "");//accumulate health of all ingredients, used in results
            all_ingredients_health01 += ingrd.GetHealth01("", "");
        }
        //------------------- results ----------------------
        for(i = 0; i < m_NumberOfResults; i++)
        {
            ItemBase res = results.Get(i);
            if(!res)
            {
                continue;
            }
            
            bool use_soft_skills = m_ResultUseSoftSkills[i];
            
            if( res.IsItemBase() )
            {
                value_delta = m_ResultSetQuantity[i];
 
                ItemBase resIb = ItemBase.Cast(res);
 
                if( use_soft_skills ) 
                {
                    value_delta = player.GetSoftSkillsManager().AddSpecialtyBonus(value_delta, m_Specialty);
                }
                
                if( !resIb.IsMagazine() )//is not a magazine
                {
                    if( m_ResultSetFullQuantity[i] == 1 )//<------m_ResultSetFullQuantity
                    {
                        resIb.SetQuantityMax();
                    }
                    else if( value_delta != -1 )//<------m_ResultSetQuantity
                    {
                        resIb.SetQuantity( value_delta );
                    }
                }
                else//is magazine
                {
                    Magazine mgzn = Magazine.Cast(resIb);
                    if( m_ResultSetFullQuantity[i] == 1 )//<------m_ResultSetFullQuantity
                    {
                        mgzn.ServerSetAmmoMax();
                    }
                    else if( value_delta != -1 )//<------m_ResultSetQuantity
                    {
                        mgzn.ServerSetAmmoCount( value_delta );
                    }
                }
            }
            if( m_ResultSetHealth[i] != -1 )//<------m_ResultSetHealth
            {
                value_delta = m_ResultSetHealth[i];
                if( use_soft_skills ) 
                {
                    value_delta = player.GetSoftSkillsManager().AddSpecialtyBonus(value_delta, m_Specialty);
                }
                res.SetHealth("","",value_delta);
            }
            if( m_ResultInheritsHealth[i] != -1 )//<------m_ResultInheritsHealth
            {
                if( m_ResultInheritsHealth[i] >= 0 )
                {
                    int ing_number = m_ResultInheritsHealth[i];
                    ItemBase ing = sorted[ing_number];
                    
                    if( ing )
                    {
                        //float ing_health = ing.GetHealth("","");
                        float ing_health01 = ing.GetHealth01("","");
                        res.SetHealth("", "", ing_health01 * res.GetMaxHealth("",""));
                        Debug.Log("Inheriting health from ingredient:"+m_ResultInheritsHealth[i].ToString(),"recipes");
                    }
                }
                else if( m_ResultInheritsHealth[i] == -2 )
                {
                    //float average_health = all_ingredients_health / MAX_NUMBER_OF_INGREDIENTS;
                    float average_health01 = all_ingredients_health01 / MAX_NUMBER_OF_INGREDIENTS;
                    res.SetHealth("", "", average_health01 * res.GetMaxHealth("",""));
                }
            }
 
            if( m_ResultReplacesIngredient[i] != -1 )//<------ResultReplacesIngredient
            {
                if( m_ResultReplacesIngredient[i] > -1 )
                {
                    int ing_num = m_ResultReplacesIngredient[i];
                    ItemBase ingr = sorted[ing_num];
                    
                    if( ingr )
                    {
                        MiscGameplayFunctions.TransferItemProperties(ingr, res);
                        MiscGameplayFunctions.TransferInventory(ingr, res, player);
                    }
                }
            }
        }
    }
    
    
    void DeleleIngredientsPass()
    {
        for(int i = 0; i < m_IngredientsToBeDeleted.Count(); i++)
        {
            ItemBase ingredient = m_IngredientsToBeDeleted.Get(i);
            ingredient.Delete();
        }
        m_IngredientsToBeDeleted.Clear();
    }
    
    //applies final modifications to ingredients
    void ApplyModificationsIngredients(ItemBase sorted[], PlayerBase player)
    {
        //---------------------- ingredients ----------------------
        for(int i = 0; i < MAX_NUMBER_OF_INGREDIENTS; i++)
        {
            ItemBase ingredient = sorted[i];
            
            if( m_IngredientDestroy[i] == 1 )//<------m_IngredientDestroy
            {
                if( ingredient ) m_IngredientsToBeDeleted.Insert(ingredient);
                //ingredient.Delete();
                //sorted[i] = NULL;
            }
            else
            {
                bool use_soft_skills = m_IngredientUseSoftSkills[i];
                
                if( m_IngredientAddHealth[i] != 0 )//<------m_IngredientAddHealth
                {
                    float health_delta = m_IngredientAddHealth[i];
                    if( use_soft_skills ) 
                    {
                        if(health_delta <0) health_delta = player.GetSoftSkillsManager().SubtractSpecialtyBonus(health_delta, m_Specialty);
                        else                health_delta = player.GetSoftSkillsManager().AddSpecialtyBonus(health_delta, m_Specialty);
                    }
                    ingredient.AddHealth("","",health_delta);
                }
                else if(m_IngredientSetHealth[i] != -1)//<------m_IngredientSetHealth
                {
                    float new_health = m_IngredientSetHealth[i];
                    ingredient.SetHealth("","",new_health);
                }
                if( m_IngredientAddQuantity[i] != 0 )//<------m_IngredientAddQuantity
                {
                    float quantity_delta = m_IngredientAddQuantity[i];
                    
                    if( use_soft_skills )
                    {
                        if(quantity_delta <0) quantity_delta = player.GetSoftSkillsManager().SubtractSpecialtyBonus(quantity_delta, m_Specialty);
                        else                quantity_delta = player.GetSoftSkillsManager().AddSpecialtyBonus(quantity_delta, m_Specialty);
                    }
                        
                    if( !ingredient.IsMagazine() )
                    {
                        ItemBase obj = ingredient;
                        bool isDestroyed = obj.AddQuantity(quantity_delta, true);
                        if( isDestroyed ) 
                        {
                            //if (obj) m_IngredientsToBeDeleted.Insert(obj);
                            continue;
                        }
                    }
                    else
                    {
                        Magazine mag = Magazine.Cast(ingredient);
                        int newQuantity = mag.GetAmmoCount() + quantity_delta;
                        if( newQuantity <= 0 )
                        {
                            if(mag) m_IngredientsToBeDeleted.Insert(mag);
                            continue;
                        }
                        else
                        {
                            mag.ServerSetAmmoCount( newQuantity );
                        }
                    }
                }
            }
        }
    }
 
    //checks the recipe conditions
    bool CheckConditions(ItemBase sorted[])
    {
        for(int i = 0; i < MAX_NUMBER_OF_INGREDIENTS; i++)
        {
            ItemBase ingredient = sorted[i];
            if( !ingredient.IsMagazine() )
            {
                if( ingredient.GetQuantityMax() !=0 && m_MinQuantityIngredient[i] >= 0 && ingredient.GetQuantity() < m_MinQuantityIngredient[i] )
                {
                    //Debug.Log("Recipe condition check failing1: m_MinQuantityIngredient","recipes");
                    return false;
                }
                if( m_MaxQuantityIngredient[i] >= 0 && ingredient.GetQuantity() > m_MaxQuantityIngredient[i] )
                {
                    //Debug.Log("Recipe condition check failing1: m_MaxQuantityIngredient","recipes");
                    return false;
                }
            }
            else
            {
                Magazine mag1 = Magazine.Cast(ingredient);
                if( m_MinQuantityIngredient[i] >= 0 && mag1.GetAmmoCount() < m_MinQuantityIngredient[i] )
                {
                    //Debug.Log("Recipe condition check failing1: m_MinQuantityIngredient[0]","recipes");
                    return false;
                }
                if( m_MaxQuantityIngredient[i] >= 0 && mag1.GetAmmoCount() > m_MaxQuantityIngredient[i] )
                {
                    //Debug.Log("Recipe condition check failing1: m_MaxQuantityIngredient[0]","recipes");
                    return false;
                }
            }
            int dmg3 = ingredient.GetHealthLevel();
            if( m_MinDamageIngredient[i] >= 0 && ingredient.GetHealthLevel() < m_MinDamageIngredient[i] )
            {
                int dmg = ingredient.GetHealthLevel();
                //Debug.Log("Recipe condition check failing1: m_MinDamageIngredient[0]","recipes");
                return false;
            }
            if( m_MaxDamageIngredient[i] >= 0 && ingredient.GetHealthLevel() > m_MaxDamageIngredient[i] )
            {
                int dmg2 = ingredient.GetHealthLevel();
                //Debug.Log("Recipe condition check failing1: m_MaxDamageIngredient[0]","recipes");
                return false;
            }
        }
        return true;
    }
 
    //checks overall validity of this recipe
    bool CheckRecipe(ItemBase item1, ItemBase item2, PlayerBase player)
    {
        if( item1 == NULL || item2 == NULL )
        {
            Error("recipe invalid, at least one of the ingredients is NULL");
            return false;
        }
        
        ItemBase item_in_hand = player.GetItemInHands();
        
        if( !IsRecipeAnywhere() && (item1 != item_in_hand && item2 != item_in_hand) )
        {
            return false;
        }
        
        m_IngredientsSorted[0] = item1;
        m_IngredientsSorted[1] = item2;
    
        if( CanDo( m_IngredientsSorted, player ) && CheckConditions( m_IngredientsSorted ) )
        {
            return true;
        }
        return false;
    }
    
    void OnSelectedRecipe(ItemBase item1, ItemBase item2, PlayerBase player)
    {
        if( item1 == NULL || item2 == NULL )
        {
            Error("CheckRecipe: recipe invalid, at least one of the ingredients is NULL");
            //Debug.Log("recipe invalid, at least one of the ingredients is NULL","recipes");
            return;
        }
        OnSelected(item1,item2,player);
    }
    
    void OnSelected(ItemBase item1, ItemBase item2, PlayerBase player)
    {
        
    }
 
    //performs this recipe
    void PerformRecipe(ItemBase item1, ItemBase item2, PlayerBase player)
    {
        if( item1 == NULL || item2 == NULL )
        {
            Error("PerformRecipe: recipe invalid, at least one of the ingredients is NULL");
            Debug.Log("PerformRecipe: at least one of the ingredients is NULL","recipes");
        }
        /*
        m_IngredientsSorted[0] = item1;
        m_IngredientsSorted[1] = item2;
        */
        
        /*
        Debug.Log("PerformRecipe Ingredient 1: "+ToString(item1.Ptr().GetType()),"recipes");
        Debug.Log("PerformRecipe Ingredient 2: "+ToString(item2.Ptr().GetType()),"recipes");
        */
        if( CheckRecipe(item1,item2,player) )
        {
            array<ItemBase> spawned_objects = new array<ItemBase>;
            SpawnItems(m_IngredientsSorted, player,spawned_objects );
            
            ApplyModificationsResults(m_IngredientsSorted, spawned_objects, NULL, player);
            ApplyModificationsIngredients(m_IngredientsSorted, player);
            
            ApplySoftSkillsSpecialty(player);
            
            Do( m_IngredientsSorted, player, spawned_objects, m_Specialty );
            
            
            DeleleIngredientsPass();
        }
        else
        {
            Debug.Log("CheckRecipe failed on server","recipes");
        }
    }
 
    void ApplySoftSkillsSpecialty(PlayerBase player)
    {
        player.GetSoftSkillsManager().AddSpecialty(m_Specialty);
    }   
    
    bool CanDo(ItemBase ingredients[], PlayerBase player)
    {
        //Debug.Log("Called Can Do on a recipe id:" + m_ID.ToString(),"recipes");
        for ( int i = 0; i < MAX_NUMBER_OF_INGREDIENTS; i++)
        {
            if (ingredients[i].GetInventory() && ingredients[i].GetInventory().AttachmentCount() > 0)
                return false;
        }
        
        return true;
    }
 
    void Do(ItemBase ingredients[], PlayerBase player, array<ItemBase> results, float specialty_weight)
    {
        //Debug.Log("Called Do on a recipe id:" + m_ID.ToString(),"recipes");
    }
 
    int GetID()
    {
        return m_ID;
    }
 
 
    void SetID(int id)
    {
        m_ID = id;
    }
 
    void GetAllItems(array<string> items)
    {
        for(int i = 0; i < MAX_NUMBER_OF_INGREDIENTS; i++)
        {
            array<string> ptr = m_Ingredients[i];
            
            for(int x = 0; x < ptr.Count(); x++)
            {
                items.Insert( ptr.Get(x) );
            }
        }
    }
    
    string GetSoundCategory(int ingredientIndex, ItemBase item)
    {
        string itemType = item.GetType();
        array<string> ptr = m_Ingredients[ingredientIndex];
        
        for (int x = 0; x < ptr.Count(); x++)
        {
            if (GetGame().IsKindOf(itemType, ptr.Get(x)))
            {
                return m_SoundCategories[ingredientIndex].Get(x);
            }
        }
        return "";
    }
    
    
    
 
    bool IsItemInRecipe(string item)
    {
        for(int i = 0; i < MAX_NUMBER_OF_INGREDIENTS; i++)
        {
            array<string> ptr = m_Ingredients[i];
            
            for(int x = 0; x < ptr.Count(); x++)
            {
                if( ptr.Get(x) == item ) return true;
            }
        }
        return false;
    }
    int GetIngredientMaskForItem(string item)
    {
        int mask = 0;
        
        for(int i = 0; i < MAX_NUMBER_OF_INGREDIENTS; i++)
        {
            array<string> ptr = m_Ingredients[i];
            
            for(int x = 0; x < ptr.Count(); x++)
            {
                if( ptr.Get(x) == item )
                {
                    mask = ((int)Math.Pow(2, i)) | mask;
                }
            }
        }
        return mask;
    }
}