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;
  }
}