static void Main(string[] args)
{
//C# method is Invariant
MusicCreater mu1 = musicCreater;
//MetalCreater me1 = mu1;
MetalCreater me2 = metalCreater;
//MusicCreater mu2 = me2;
//Convariance
//Creater<Music> mu3 = musicCreater;
//Creater<Metal> me3 = mu3;//get music include metal or classic or pop NG
Creater <Metal> me4 = metalCreater;
Creater <Music> mu4 = me4; //get metal, metal is music
MusicCreater mu5 = metalCreater; // (out is not nessary)
//MetalCreater me5 = musicCreater;
CreaterClass <Metal> me6 = new CreaterClass <Metal>();
ICreate <Music> imusic = me6;
//CreaterClass<Music> mu6 = new CreaterClass<Music>();
//ICreate<Metal> imetal = mu6;
//Contravariance
//Eater<Bamboo> ba1 = x => { };
//Eater<Food> fo1 = ba1; // dispose food, not only bamboo but also other thing is food too
Eater <Food> fo2 = x => { };
Eater <Bamboo> ba2 = fo2; // dispose bamboo, bamboo is food
//EaterClass<Bamboo> ba3 = new EaterClass<Bamboo>();
//IEat<Food> ifood = ba3;
EaterClass <Food> fo3 = new EaterClass <Food>();
IEat <Bamboo> ibamboo = fo3;
}
public override ExpressionKind Eat(ISnapshot snapshot, IBinaryExpression expression)
{
var leftKind = Eater.Eat(snapshot, expression.LeftOperand);
snapshot.Add(leftKind, expression.LeftOperand);
var rightKind = Eater.Eat(snapshot, expression.RightOperand);
snapshot.Add(rightKind, expression.RightOperand);
if (leftKind == ExpressionKind.TargetCall || rightKind == ExpressionKind.TargetCall)
{
return(ExpressionKind.Result);
}
if (leftKind == ExpressionKind.Target || rightKind == ExpressionKind.Target)
{
return(ExpressionKind.Target);
}
if (leftKind == ExpressionKind.Result || rightKind == ExpressionKind.Result)
{
return(ExpressionKind.Result);
}
return(ExpressionKind.StubCandidate);
}
private void selectEater(object sender, SelectionChangedEventArgs e)
{
Eater eat = (Eater)listView.SelectedItem;
labelNameEater.Content = eat.name;
selectedEater = eat;
}
public override ExpressionKind Eat(ISnapshot snapshot, IAsExpression expression)
{
var operandKind = Eater.Eat(snapshot, expression.Operand);
var typeUsageKind = _typeEater.EatCastType(snapshot, expression.TypeOperand);
return(_kindHelper.ValueOfKindAsTypeOfKind(operandKind, typeUsageKind));
}
public override void Eat(ISnapshot snapshot, IBlock statement)
{
foreach (ICSharpStatement inBlockStatement in statement.Statements.OfType <ICSharpStatement>())
{
Eater.Eat(snapshot, inBlockStatement);
}
}
public override ExpressionKind Eat(ISnapshot snapshot, IQueryExpression expression)
{
Eater.Eat(snapshot, expression.From.Expression);
snapshot.Add(expression.From.Declaration);
IQuerySelectClause lastSelect;
foreach (var queryClause in expression.Clauses)
{
Eater.Eat(snapshot, queryClause);
}
lastSelect = expression.Clauses.Last() as IQuerySelectClause;
foreach (var queryContinuation in expression.Continuations)
{
snapshot.Add(queryContinuation.Declaration);
foreach (var queryClause in queryContinuation.Clauses)
{
Eater.Eat(snapshot, queryClause);
}
lastSelect = queryContinuation.Clauses.Last() as IQuerySelectClause;
}
// the final query kind is provided based on type of last select clause
// so if it return stubs(for example), all query returns stubs
return(Eater.Eat(snapshot, lastSelect));
}
public void TryToEat_VictimIsNull_ThrowsException()
{
var predator = new Ogre(200, 100);
var eater = new Eater(predator);
Assert.Throws <ArgumentNullException>(() => eater.TryToEat(null));
}
protected override void OnTick()
{
Eaten--;
if (Eater == null || Eater.Deleted || Eaten <= 0)
{
Stop();
ToothAches.Remove(Eater);
}
else if (Eater.Map != Map.Internal && Eater.Alive)
{
if (Eaten > 60)
{
Eater.Say(1077388 + Utility.Random(5)); // ARRGH! My tooth hurts sooo much!, etc.
if (Utility.RandomBool())
{
Eater.Animate(32, 5, 1, true, false, 0);
}
}
else if (Eaten == 60)
{
Eater.SendLocalizedMessage(1077393); // The extreme pain in your teeth subsides.
}
}
}
// Use this for initialization
void Awake()
{
eater = GameObject.FindObjectOfType <Eater>().GetComponent <Eater>();
gameManager = GameObject.Find("GameManager").GetComponent <GumGameManager>();
audioManager = GameObject.Find("AudioManager").GetComponent <AudioManager>();
uneatenFood.AddRange(GameObject.FindGameObjectsWithTag("Food"));
}
protected override void OnTick()
{
--Eaten;
if (Eater?.Deleted != false || Eaten <= 0)
{
Stop();
m_ToothAches.Remove(Eater);
}
else if (Eater.Map != Map.Internal && Eater.Alive)
{
if (Eaten > 60)
{
Eater.Say(1077388 + Utility.Random(5));
/* ARRGH! My tooth hurts sooo much!
* You just can't find a good Britannian dentist these days...
* My teeth!
* MAKE IT STOP!
* AAAH! It feels like someone kicked me in the teeth!
*/
if (Utility.RandomBool() && Eater.Body.IsHuman && !Eater.Mounted)
{
Eater.Animate(32, 5, 1, true, false, 0);
}
}
else if (Eaten == 60)
{
Eater.SendLocalizedMessage(1077393); // The extreme pain in your teeth subsides.
}
}
}
public void increment_hunger()
{
eater = new Eater(hunger: 0);
var result = Eater.Update(EaterMsg.IncrementHunger, eater);
Assert.AreEqual(1, result.hunger);
}
public override void Eat(ISnapshot snapshot, IWhileStatement statement)
{
Eater.Eat(snapshot, statement.Body);
var condKind = Eater.Eat(snapshot, statement.Condition);
snapshot.Add(condKind, statement.Condition);
}
public void happy_state()
{
eater = new Eater(hunger: 1);
var result = Eater.Update(EaterMsg.DecreaseHunger, eater, new DecreaseHunger(3));
Assert.AreEqual(EaterState.Happy, result.state);
}
public override void Eat(ISnapshot snapshot, ISwitchStatement statement)
{
Eater.Eat(snapshot, statement.Block);
var condKind = Eater.Eat(snapshot, statement.Condition);
snapshot.Add(condKind, statement.Condition);
}
public static Pizza WithOrder(this Pizza pizza, string name, int slices)
{
var eater = new Eater(name);
pizza.OrderSlice(eater, slices);
return(pizza);
}
public override void Eat(ISnapshot snapshot, ILockStatement statement)
{
Eater.Eat(snapshot, statement.Body);
var condKind = Eater.Eat(snapshot, statement.Monitor);
snapshot.Add(condKind, statement.Monitor);
}
public override ExpressionKind Eat(ISnapshot snapshot, IIsExpression expression)
{
var kind = Eater.Eat(snapshot, expression.Operand);
snapshot.Add(kind, expression.Operand);
return(ExpressionKind.StubCandidate);
}
// Start is called before the first frame update
void Start()
{
startPos = transform.position;
//GetComponent<AudioSource>().clip = Resources.Load<AudioClip>(gameObject.name);
foodPicker = GameObject.FindObjectOfType<FoodPicker>();
eater = FindObjectOfType<Eater>().GetComponent<Eater>();
audioManager = GameObject.Find("AudioManager").GetComponent<AudioManager>();
}
public void sad_state()
{
eater = new Eater(hunger: 0);
var result = Eater.Update(EaterMsg.IncrementHunger, eater);
Assert.AreEqual(EaterState.Sad, result.state);
}
public void decrease_hunger()
{
eater = new Eater(hunger: 10);
var parameters = new DecreaseHunger(5);
var result = Eater.Update(EaterMsg.DecreaseHunger, eater, parameters);
Assert.AreEqual(5, result.hunger);
}
public override void Eat(ISnapshot snapshot, IUnsafeCodeFixedStatement statement)
{
Eater.Eat(snapshot, statement.Body);
foreach (var declaration in statement.PointerDeclarations)
{
Eater.Eat(snapshot, declaration);
}
}
public override void Eat(ISnapshot snapshot, IForeachStatement statement)
{
Eater.Eat(snapshot, statement.Body);
Eater.Eat(snapshot, statement.IteratorDeclaration);
var kind = Eater.Eat(snapshot, statement.Collection);
snapshot.Add(kind, statement.Collection);
}
public override void Eat(ISnapshot snapshot, IUsingStatement statement)
{
foreach (var localVariableDeclaration in statement.VariableDeclarations)
{
Eater.Eat(snapshot, localVariableDeclaration);
}
Eater.Eat(snapshot, statement.Body);
}
public void TryToEat_WeakPredatorAndStrongVictimHaveNoParties_Fails()
{
var predator = new Ogre(200, 100);
var victim = new Goblin(2000, 100);
var eater = new Eater(predator);
bool success = eater.TryToEat(victim);
Assert.IsFalse(success);
}
public void TryToEat_StrongPredatorAndWeakVictimHaveNoParties_Suceeds()
{
var predator = new Ogre(200, 100);
var victim = new Ogre(200, 100);
var eater = new Eater(predator);
bool success = eater.TryToEat(victim);
Assert.IsTrue(success);
}
public override ExpressionKind Eat(ISnapshot snapshot, IElementAccessExpression expression)
{
_argumentsEater.Eat(snapshot, expression.Arguments);
// TODO : cover by functional tests
// TODO : what if array of results or targets
Eater.Eat(snapshot, expression.Operand);
return(ExpressionKind.StubCandidate);
}
// Start is called before the first frame update
void Start()
{
eater = GameObject.FindGameObjectWithTag("Eater").GetComponent <Eater>();
canBeHurt = true;
healthBar = GameObject.FindGameObjectWithTag("HealthBar").GetComponent <HealthBar>();
GameObject startingWaypoint = Instantiate(waypoint, transform.position, transform.rotation);
GameObject.FindGameObjectWithTag("Eater").GetComponent <Eater>().setTarget(startingWaypoint);
lastWaypoint = startingWaypoint;
StartCoroutine(CreateWaypoints());
}
void Start()
{
_eater = GetComponent <Eater>();
_rigidbody = GetComponent <Rigidbody2D>();
_active = true;
_goals = FindObjectsOfType <CowSpawner>();
StartCoroutine(SwitchGoal());
StartCoroutine(Live());
}
public override ExpressionKind Eat(ISnapshot snapshot, IAnonymousObjectCreationExpression expression)
{
// TODO: cover by functional tests
foreach (var memberDeclaration in expression.AnonymousInitializer.MemberInitializers)
{
var kind = Eater.Eat(snapshot, memberDeclaration.Expression);
snapshot.Add(kind, memberDeclaration);
}
return(ExpressionKind.StubCandidate);
}
public Meal(Cook cook, Eater eater, String date, String food)
{
this.cook = cook;
this.eater = eater;
this.date = date;
this.food = food;
this.status = "Awaiting";
IsReview = false;
IsAccepted = false;
eater.numberMeals = eater.numberMeals + 1;
}
private void Button_Click(object sender, RoutedEventArgs e)
{
Eater Eater = new Eater();
List<object> Param = new List<object>() { Eater };
Frame.Navigate(typeof(EatingPage), Param);
}
