public Burger(Meet meet, Cheeseness cheeseness, List <AddonType> addonTypes, BurgerType burgerType)
{
BurgerType = burgerType;
Meet = meet;
Cheeseness = cheeseness;
Addons = addonTypes;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="burger">Type of burger</param>
/// <param name="cookedLevels">How cooked the burger is</param>
/// <param name="heat">Heat of the burger</param>
/// <param name="colour">Colour of the burger</param>
public BurgerPatty(BurgerType burger, float[] cookedLevels, float heat, Color colour)
{
_type = burger;
_cookedLevel = cookedLevels;
_heat = heat;
_colour = colour;
}
public void CheckUsedTool(ToolType usedTool)
{
if (currentTargetBurger != null)
{
BurgerType targetBurgerType = currentTargetBurger.GetComponent <Script_Burger>().type;
if (targetBurgerType == BurgerType.hight && usedTool == ToolType.Spatule)
{
CorrectTool();
}
else if (targetBurgerType == BurgerType.longer && usedTool == ToolType.Knife)
{
CorrectTool();
}
else if (targetBurgerType == BurgerType.divide && usedTool == ToolType.Tongs)
{
CorrectTool();
}
else if (targetBurgerType == BurgerType.small && usedTool == ToolType.Sucker)
{
CorrectTool();
}
else
{
BadTool();
}
}
else
{
BadTool();
}
}
public void SpawnARandomBurger()
{
BurgerType burgerToSpawn = BurgerType.good;
if (Random.Range(0, 101) > chanceToSpawnGoodBuger)
{
int randomBurgerIdx = Random.Range(0, 4);
switch (randomBurgerIdx)
{
case 0:
burgerToSpawn = BurgerType.divide;
break;
case 1:
burgerToSpawn = BurgerType.hight;
break;
case 2:
burgerToSpawn = BurgerType.longer;
break;
case 3:
burgerToSpawn = BurgerType.small;
break;
}
}
SpawnSpecificBurger(burgerToSpawn, burgerSpawnPoint.transform.position);
}
public Burger(string name, IList <BurgerIngredient> burgerIngredients, BurgerType type, string description = null)
{
Name = name;
Description = description;
Type = type;
BurgerIngredients = new List <BurgerIngredient>(burgerIngredients);
}
private void cmbType_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
txtPrice.Text = cmbType.SelectedValue.ToString();
KeyValuePair <BurgerType, double> selectedEntry =
(KeyValuePair <BurgerType, double>)cmbType.SelectedItem;
selectedBurger = selectedEntry.Key;
}
public void SpawnSpecificBurger(BurgerType burgerToSpawn, Vector3 spawnPosition)
{
int inputsUIIdx = 0;
if (Gamepad.current != null)
{
if (Gamepad.current.displayName == "Xbox Controller")
{
inputsUIIdx = 1;
}
else if (Gamepad.current.displayName == "Wireless Controller")
{
inputsUIIdx = 2;
}
}
GameObject newBurger = null;
Sprite inputSpr = null;
switch (burgerToSpawn)
{
case BurgerType.good:
newBurger = Instantiate(burgerGood, spawnPosition, Quaternion.identity);
inputSpr = inputUIList[inputsUIIdx].nothingInputSpr;
break;
case BurgerType.divide:
newBurger = Instantiate(burgerDivide, spawnPosition, Quaternion.identity);
inputSpr = inputUIList[inputsUIIdx].tongsInputSpr;
break;
case BurgerType.small:
newBurger = Instantiate(burgerSmall, spawnPosition, Quaternion.identity);
inputSpr = inputUIList[inputsUIIdx].suckerInputSpr;
break;
case BurgerType.hight:
newBurger = Instantiate(burgerHight, spawnPosition, Quaternion.identity);
inputSpr = inputUIList[inputsUIIdx].spatuleInputSpr;
break;
case BurgerType.longer:
newBurger = Instantiate(burgerLong, spawnPosition, Quaternion.identity);
inputSpr = inputUIList[inputsUIIdx].knifeInputSpr;
break;
}
AddBurgerToList(newBurger);
newBurger.GetComponent <Script_Burger>().Move(Vector3.left, currentSpeed);
newBurger.GetComponent <Script_Burger>().SetupInputIndication(inputSpr);
}
public Burger GetBurger(BurgerType type)
{
switch (type)
{
case BurgerType.BEEF:
return(new BeefBurger());
case BurgerType.VEG:
return(new VegBurger());
default:
return(null);
}
}
private void AddToOrder_Click(object sender, RoutedEventArgs e)
{
DrinkType drinkType = (DrinkType)Convert.ToInt32(SelectedDrinkType.SelectedValue);
BurgerType burgerType = (BurgerType)Convert.ToInt32(SelectedBurgerType.SelectedValue);
MenuSize menuSize = (MenuSize)Convert.ToInt32(SelectedMenuSize.SelectedValue);
IMenuFactory menuFactory = new MenuFactory();
var menu = builder.PrepareBurger(menuFactory.GetBurger(burgerType), menuFactory.GetDrink(drinkType), menuSize);
currentOrder.AddMenu(menu);
ReinitOrderSource();
}
static Cook CreateCook(BurgerType burgerType)
{
switch (burgerType)
{
case BurgerType.BigMac:
return(new CookBigMac());
case BurgerType.CheeseBurger:
return(new CookCheeseBurger());
case BurgerType.Mine:
return(new MyBurger());
}
return(null);
}
public override ISandwich MakeBurgerSandwich(BurgerType type)
{
List<string> ingredients;
ISandwich burgerSandwich;
string garnish = string.Empty;
switch (type)
{
case BurgerType.Beef:
ingredients = new List<string>()
{
"beef",
"ketchup",
"lettuce"
};
garnish = "French fries";
burgerSandwich = new BurgerSandwich(ingredients, garnish, type);
break;
case BurgerType.Cheese:
ingredients = new List<string>()
{
"cheese",
"ketchup",
"butter"
};
garnish = string.Empty;
burgerSandwich = new BurgerSandwich(ingredients, garnish, type);
break;
case BurgerType.Chicken:
ingredients = new List<string>()
{
"chicken",
"ketchup",
"lettuce"
};
garnish = "French fries";
burgerSandwich = new BurgerSandwich(ingredients, garnish, type);
break;
default: throw new ArgumentException();
}
return burgerSandwich;
}
/// <summary>
/// Get the minimum value for perfectly cooked for the specified burger
/// </summary>
/// <param name="type">The type of burger to check</param>
/// <returns>The minimum value that needs to be hit for the burger to be perfectly cooked</returns>
public static float MinCookedLevel(BurgerType type)
{
float value = 1f;
// get the correct threshold based on the type
switch (type)
{
case BurgerType.Beef: value = MIN_COOKED_LEVEL_BEEF; break;
case BurgerType.Chicken: value = MIN_COOKED_LEVEL_CHICKEN; break;
case BurgerType.Veggie: value = MIN_COOKED_LEVEL_VEGGIE; break;
default: System.Diagnostics.Debug.Assert(false, "Invalid burger type specified"); break;
}
return(value);
}
private int ValidateQuantity(BurgerType selectedBurger)
{
int q = int.Parse(txtQuantity.Text);
int r = 1;
switch (selectedBurger)
{
case BurgerType.Susan:
if (q > mSusanBread)
{
r = 0;
}
break;
case BurgerType.Simple:
if (q > mSimpleBread)
{
r = 0;
}
break;
case BurgerType.Meat:
if (q > mMeatFilled)
{
r = 0;
}
break;
case BurgerType.Cheese:
if (q > mCheeseFilled)
{
r = 0;
}
break;
case BurgerType.Salad:
if (q > mSaladFilled)
{
r = 0;
}
break;
}
return(r);
}
public Burger(int id, string name, BurgerType type, decimal price, string pictureUrl, string description)
{
if (price <= 0)
{
throw new InvalidPriceException("Burger price can not be zero or less.");
}
if (string.IsNullOrEmpty(name))
{
throw new InvalidNameException("Burger name can not be empty.");
}
Id = id;
Name = name;
Type = type;
Price = price;
PictureUrl = pictureUrl;
Description = description;
}
public static Burger makeBurger(BurgerType type)
{
Burger burger = null;
Location location = Location.INDIA;
switch (location)
{
case USA:
burger = USABurgerFactory.makeBurger(type);
break;
case INDIA:
burger = IndiaBurgerFactory.makeBurger(type);
break;
default:
burger = DefaultBurgerFactory.makeBurger(type);
}
return(burger);
}
public static double GetBurgerPrice(BurgerType burgerType)
{
switch (burgerType)
{
case BurgerType.Hamburger:
return(25.00);
case BurgerType.Cheeseburger:
return(27.45);
case BurgerType.BigBurger:
return(29.50);
case BurgerType.MegaBurger:
return(31.85);
case BurgerType.DoubleMeatBurger:
return(36.99);
default:
throw new ArgumentException("This burger's price is not on our menu!");
}
}
static Burger makeBurger(BurgerType type)
{
Burger burger = null;
switch (type)
{
case MINI:
burger = new MiniBurger(Location.INDIA);
break;
case STANDART:
burger = new StandartBurger(Location.INDIA);
break;
case MAXI:
burger = new MaxiBurger(Location.INDIA);
break;
default:
break;
}
return(burger);
}
public static Burger Create(ShopType shopType, BurgerType burgerType)
{
//// 製作漢堡的工廠
IBurgerFactory burgerFactory = null;
if (burgerType == BurgerType.Chicken)
{
burgerFactory = new ChickenBurgerFactory();
}
else if (burgerType == BurgerType.Pork)
{
burgerFactory = new PorkBurgerFactory();
}
else if (burgerType == BurgerType.Fish)
{
burgerFactory = new FishBurgerFactory();
}
//// 提供原料工廠
IIngredientFactory ingredientFactory = null;
if (shopType == ShopType.Taipei)
{
ingredientFactory = new TaipeiIngredientFactory();
}
else if (shopType == ShopType.NewYork)
{
ingredientFactory = new NewYorkIngredientFactory();
}
else if (shopType == ShopType.Tokyo)
{
ingredientFactory = new TokyoIngredientFactory();
}
//// 使用原料工廠提共的原料製作漢堡
return(burgerFactory.Create(ingredientFactory));
}
/// <summary>
/// Sets the type of the burger in use
/// </summary>
/// <param name="burgerIndex">Index of the burger</param>
internal void SetBurgerType(int burgerIndex)
{
_type = (BurgerType)Enum.Parse(typeof(BurgerType), burgerIndex.ToString());
var max = 0f;
var min = 0f;
switch (_type)
{
// beef
case BurgerType.Beef:
min = BurgerPatty.MIN_COOKED_LEVEL_BEEF;
max = BurgerPatty.MAX_COOKED_LEVEL_BEEF;
break;
// chicken
case BurgerType.Chicken:
min = BurgerPatty.MIN_COOKED_LEVEL_CHICKEN;
max = BurgerPatty.MAX_COOKED_LEVEL_CHICKEN;
break;
// veggie
case BurgerType.Veggie:
min = BurgerPatty.MIN_COOKED_LEVEL_VEGGIE;
max = BurgerPatty.MAX_COOKED_LEVEL_VEGGIE;
break;
}
// get perfectly cooked area position
var size = max - min;
var middle = (max + min) / 2;
// set perfectly cooked area position
PerfectlyCooked.localPosition = new Vector3(PerfectlyCooked.localPosition.x, 0.5f + (0 - middle), PerfectlyCooked.localPosition.z);
PerfectlyCooked.localScale = new Vector3(1, size, 1);
}
public Burger GetBurgerByType(BurgerType type)
{
var burger = _localBurgerDb.FirstOrDefault(filter => filter.Type == type);
return(new Burger(burger.Name, burger.BurgerIngredients, burger.Type, burger.Description));
}
public BurgerSandwich(List<string> ingredients, string garnish, BurgerType type)
: base(ingredients, garnish)
{
this.Type = type;
}
void setType(BurgerType type)
{
this.type = type;
}
Burger(BurgerType type, Location location)
{
this.type = type;
this.location = location;
}
public Burger GetBurgerByType(BurgerType burgerType)
{
return(_repository.GetBurgerByType(burgerType));
}
public Burger(BurgerType aFlavor)
{
mFlavor = aFlavor;
}
public abstract ISandwich MakeBurgerSandwich(BurgerType type);
public ISandwich GetBurgerSandwich(BurgerType type)
{
return this.restaurant.MakeBurgerSandwich(type);
}
public Burger(BurgerType type, decimal mainCost, decimal miscCost)
{
TypeOfBurger = type;
MainCost = mainCost;
MiscCost = miscCost;
}
public Burger(BurgerType itemName, double price)
{
ItemName = itemName;
Price = price;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="burger">Type of burger</param>
public BurgerPatty(BurgerType burger)
{
_type = burger;
}
