public static string GetVegId(VegetableType vegType)
{
switch (vegType)
{
case VegetableType.ARTICHOKE:
return("A");
case VegetableType.BROCCOLLI:
return("B");
case VegetableType.CUCUMBER:
return("C");
case VegetableType.DASHEEN:
return("D");
case VegetableType.EGGPLANT:
return("E");
case VegetableType.FENNEL:
return("F");
default:
return("INVALID");
}
}
void Start()
{
string name = gameObject.name;
vegetableType = (VegetableType)Enum.Parse (typeof(VegetableType), name);
value = (int)vegetableType;
}
void Start()
{
string name = gameObject.name;
vegetableType = (VegetableType)Enum.Parse(typeof(VegetableType), name);
value = (int)vegetableType;
}
public void AddToSalad(VegetableType vegetableToAdd)
{
if (saladOnBoard.myType != VegetableType.All && (saladOnBoard.myType & vegetableToAdd) != vegetableToAdd)
{
numberOfItemsInSalad += 1;
saladOnBoard.myType = saladOnBoard.myType | vegetableToAdd;
saladOnBoard.SetSaladComponents();
}
}
void SetComponentsType()
{
for (int i = 0; i < numberOfTypesInRequest; i++)
{
temp = (VegetableType)typesToChooseFrom[Random.Range(0, typesToChooseFrom.Count)];
myRequest.myType = myRequest.myType | temp;
typesToChooseFrom.Remove(temp);
}
}
public Vegetable GetVegetable(VegetableType type)
{
switch (type)
{
case VegetableType.Carrot:
return(new Carrot());
case VegetableType.Potato:
return(new Potato());
default:
throw new InvalidOperationException("Unknown vegetable type.");
}
}
public void AddVegetable(VegetableType vegType)
{
if (m_ChoppedList != null)
{
if (m_ChoppedList.Count == MAX_VEGETABLES)
{
return;
}
Vegetable veg = LevelManager.Instance.CreateVegetable(vegType);
veg.transform.SetParent(this.transform);
veg.pOwner = this.gameObject.GetComponent <PlayerController>();
m_CurrentVegOnBoard = veg;
Utilities.Util.SetDefaultLocalTransform(veg.gameObject);
SetState(ChoppingBoardState.COLLECTED_VEG);
}
}
public Vegetable GetVegetable(VegetableType type)
{
Vegetable vegetable;
switch (type)
{
case VegetableType.Carrot:
vegetable = new Carrot();
break;
case VegetableType.Potato:
vegetable = new Potato();
break;
default:
throw new ArgumentException(string.Format("Cannot create vegetable of type {0}", type));
}
Console.WriteLine("Getting a {0}...", vegetable.Name);
return vegetable;
}
private void Interaction()
{
Collider2D collider = Physics2D.OverlapCircle(transform.position, .5f, checkableLayer);
if (collider != null)
{
string s = collider.tag;
switch (s)
{
case "Plate":
if (player.inventory.Count > 0 && player.inventory[0].typeOfVegetable != VegetableType.Combo)
{
collider.GetComponent <Vegetable>().GetVegetable(player.inventory[0]);
player.RemoveVegetable();
}
break;
case "Vegetable":
VegetableType vtype = collider.GetComponent <Vegetable>().typeOfVegetable;
Vegetable vege = player.inventory.Find(v => v.typeOfVegetable == vtype);
player.inventory.Remove(vege);
break;
case "CuttingBoard":
CuttingBoard cb = collider.GetComponent <CuttingBoard>();
if (cb.vegePlate.vegetablesOnPlate.Count != 0)
{
player.AddToVegePlate(cb.vegePlate);
cb.ClearVegePlate();
}
break;
case "Trash":
player.RemoveVegePlate();
GameManager.Instance.PointDistribution(player, -50);
break;
default:
break;
}
}
}
public void CheckPlates(VegePlate vegePlate, Player player)
{
AddPlayer(player);
if (vegePlate.vegetablesOnPlate.Count == plateRequest.Count)
{
//Part1 Check if vegePlate has the ingredients
for (int i = 0; i < plateRequest.Count; i++)
{
VegetableType vType = plateRequest[i].typeOfVegetable;
if (vegePlate.vegetablesOnPlate.Contains(plateRequest[i]))//(vegePlate.vegetablesOnPlate.Find(s => s.typeOfVegetable == vType))
{
vegePlate.vegetablesOnPlate.Remove(vegePlate.vegetablesOnPlate.Find(s => s.typeOfVegetable == vType));
correctNumberOfIngredients++;
}
}
//Part2 decides what mood the customer will be in
if (correctNumberOfIngredients == plateRequest.Count)
{
float happinessCheck = currentPatience / customerPatience;
if (happinessCheck > .70f)
{
ChangeMood(CustomerMood.Happy);
}
else
{
ChangeMood(CustomerMood.Satisfied);
}
correctNumberOfIngredients = 0;
CheckResult(player, scoreBonus);
}
else
{
IncorrectOrder();
}
}
else
{
IncorrectOrder();
}
}
private void Hide()
{
myState = EnemyStates.Hidden;
ResetAcceptableVegetableTypes();
CheckNearVegetables();
// Ignore the vegetable types around
foreach (GameObject veg in nearVegetables)
{
VegetableType nearVegType = veg.GetComponent <Vegetable>().vegetableType;
if (acceptableVegetableTypes.Contains(nearVegType))
{
acceptableVegetableTypes.Remove(nearVegType);
}
}
// Change the animation
myAnimator.SetBool("IsHiding", true);
myAnimator.SetFloat("HideType", hideMap[acceptableVegetableTypes[Random.Range(0, acceptableVegetableTypes.Count)]]);
}
string GetVegName(VegetableType vegType)
{
switch (vegType)
{
case VegetableType.ARTICHOKE:
return("ARTICHOKE");
case VegetableType.BROCCOLLI:
return("BROCCOLLI");
case VegetableType.CUCUMBER:
return("CUCUMBER");
case VegetableType.DASHEEN:
return("DASHEEN");
case VegetableType.EGGPLANT:
return("EGGPLANT");
case VegetableType.FENNEL:
return("FENNEL");
}
return("INVALID");
}
public Vegetables(double price, int count, VegetableType type, DealerCountry country) : base(price, count)
{
Id = System.Threading.Interlocked.Increment(ref m_Counter);
Country = country;
Type = type;
}
public BlankSpace(IMatrixPosition position, int growthTime, VegetableType vegetableType)
: base(position, DefaultBlankSpaceCharValue)
{
this.GrowthTime = growthTime;
this.VegetableHolder = vegetableType;
}
public Vegetable(VegetableType type)
{
this.Type = type;
}
public void GetVegetable(Vegetable vege)
{
typeOfVegetable = vege.typeOfVegetable;
ChangeVegetable();
}
public Vegetable CreateVegetable(VegetableType veg)
{
GameObject go = (GameObject)Instantiate(Resources.Load(VEGETABLE_ASSETS_PATH + "/" + veg.ToString()));
return(go.GetComponent <Vegetable>());
}
public Vegetable(VegetableType vegetableType)
{
this.vegetableType = vegetableType;
this.hp += (int)vegetableType;
}
