static void Main(string[] args)
{
//Create a hierarchy Dog, Frog, Cat, Kitten, Tomcat and define useful
//constructors and methods. Dogs, frogs and cats are Animals. All animals
//can produce sound (specified by the ISound interface). Kittens and
//tomcats are cats. All animals are described by age, name and sex. Kittens
//can be only female and tomcats can be only male. Each animal produces a specific
//sound. Create arrays of different kinds of animals and calculate the average
//age of each kind of animal using a static method (you may use LINQ).
//Make some animals and test their properties
Kitten kitty = new Kitten(3, "Kitty");//the sex is aways female
Console.WriteLine(kitty.Name + "-" + kitty.Age + "-" + kitty.sex);
kitty.ProduceSound();
Tomkat tom = new Tomkat(5, "Tom");//the sex is aways male
Console.WriteLine(tom.Name + "-" + tom.Age + "-" + tom.sex);
tom.ProduceSound();
Dog doggy = new Dog(8, "Doggy", Sex.male);
Console.WriteLine(doggy.Name + "-" + doggy.Age + "-" + doggy.sex);
doggy.ProduceSound();
Frog froggy = new Frog(1, "Froggy", Sex.female);
Console.WriteLine(froggy.Name + "-" + froggy.Age + "-" + froggy.sex);
froggy.ProduceSound();
//Make array with diferent animals and calculate the average age for every animal type in the array
Animal[] animals = {kitty,tom,froggy,doggy,
new Kitten(4,"Keit"),
new Tomkat(5,"Tomas"),
new Dog(11,"Rex",Sex.male),
new Frog(3,"Curmit",Sex.male)};
CalculateEveryAnimalAverageAge(animals);
}
static void Main()
{
Cat tommy = new Cat("Tommy" ,2 ,Sex.male);
Dog sharo = new Dog("Sharo" , 3 ,Sex.male);
Frog princess = new Frog("Afrodita" , 5 , Sex.female);
Kitten milka = new Kitten("Milka" , 4 , Sex.female);
TomCat tom = new TomCat("Tom" , 1 , Sex.male);
zooPark = new Animal[] { tommy, sharo ,princess , milka , tom}; // <-- Is this an abstract ? A: maybe calling a array is possible ...
foreach (var animal in zooPark)
{
Console.WriteLine(animal);
switch (animal.GetType().Name)
{
case "Dog":
Dog doggy = animal as Dog;
doggy.Talk();
break;
case "Cat":
Cat catty = animal as Cat;
catty.Talk();
break;
case "Frog":
Frog frogie = animal as Frog;
frogie.Talk();
break;
default:
break;
}
}
CalculateAverageAge();
Console.WriteLine("\n\r\n\rTo see that condition for male checking of kitten and TOmcat works");
// See implemented method below
CheckSexAnimal();
}
private static void Main()
{
IList<Animal> animals = new List<Animal>
{
new Cat("Maca",2, Genders.Female),
new Cat("Kotio", 4, Genders.Male),
new Dog("Balkan", 1, Genders.Male),
new Dog("Sharo", 6, Genders.Male),
new Frog("Tinka", 4, Genders.Female),
new Frog("Gruncho", 7, Genders.Male),
new Kitten("Mariika", 2),
new Tomcat("Gancho", 2)
};
var groupAnimals = from animal in animals
group animal by (animal is Cat) ? typeof(Cat) : animal.GetType()
into g
select new { GroupName = g.Key, AverageAge = g.ToList().Average(a => a.Age) };
foreach (var animal in groupAnimals)
{
Console.WriteLine("{0} - average age: {1:N2}", animal.GroupName.Name, animal.AverageAge);
}
Console.WriteLine();
Animal rex = new Dog("Rex", 10, Genders.Male);
Animal gosho = new Cat("Gosho", 5, Genders.Male);
Animal tina = new Frog("Tina", 4, Genders.Female);
rex.ProduceSound();
gosho.ProduceSound();
tina.ProduceSound();
}
static void Main()
{
//
Cat somecat = new Cat("Monika_Cat",4,"female");
somecat.ProduceSound();
Kitten kitten = new Kitten("Vesi_Kitten", 5);
kitten.ProduceSound();
Console.WriteLine(kitten.Sex);
Tomcat tomCat = new Tomcat("Tomas_TomCat", 6);
tomCat.ProduceSound();
Console.WriteLine(tomCat.Sex);
Frog kyrmit = new Frog("Kyrmit_Jabok", 2, "male");
Dog rex = new Dog("Rex_Dog", 7, "male");
Dog hera = new Dog("Hera_Dog", 8, "female");
List<Animal> animalsList = new List<Animal>();
Cat lora = new Cat("Lora_Cat", 3, "female");
animalsList.Add(somecat);
animalsList.Add(kitten);
animalsList.Add(tomCat);
animalsList.Add(kyrmit);
animalsList.Add(rex);
animalsList.Add(hera);
animalsList.Add(lora);
//Average groups age
var animalGroups =
from animal in animalsList
group animal by animal.GetType();
foreach (var animals in animalGroups)
{
Console.WriteLine(animals.myAverage());
}
}
static void Main()
{
Dog dogOne = new Dog("Sharo", "male", 7);
Dog dogTwo = new Dog("Sara", "female", 17);
Dog dogThree = new Dog("Tara", "female", 1);
Dog[] dogArr = new Dog[] { dogOne, dogTwo, dogThree };
Console.WriteLine("The average age of dogs is {0:F2} years old.", Animal.CalculateAverage(dogArr));
Console.WriteLine("Dog {0} says {1}.", dogThree.Name, dogThree.PrintSound());
Frog frogOne = new Frog("Skokla", "female", 23);
Frog frogTwo = new Frog("Handsome", "male", 9);
Frog frogThree = new Frog("Skokancho", "male", 2);
Frog[] frogArr = new Frog[] { frogOne, frogTwo, frogThree };
Console.WriteLine("The average age of frogs is {0:F2} years old.", Animal.CalculateAverage(frogArr));
Console.WriteLine("Frog {0} says {1}.", frogThree.Name, frogThree.PrintSound());
Kitten kittenOne = new Kitten("Hihi", 1);
Kitten kittenTwo = new Kitten("Kiki", 1);
Kitten kittenThree = new Kitten("Kenny", 2);
Kitten[] kittenArr = new Kitten[] { kittenOne, kittenTwo, kittenThree };
Console.WriteLine("The average age of kittens is {0:F2} years old.", Animal.CalculateAverage(kittenArr));
Console.WriteLine("Kitten {0} says {1}.", kittenThree.Name, kittenThree.PrintSound());
Tomcat tomcatOne = new Tomcat("Pancho", 4);
Tomcat tomcatTwo = new Tomcat("Robby", 3);
Tomcat tomcatThree = new Tomcat("Vasko", 8);
Tomcat[] tomcatArr = new Tomcat[] { tomcatOne, tomcatTwo, tomcatThree };
Console.WriteLine("The average age of tomcats is {0:F2} years old.", Animal.CalculateAverage(tomcatArr));
Console.WriteLine("Tomcat {0} says {1}.", tomcatThree.Name, tomcatThree.PrintSound());
}
// Use this for initialization
void Start()
{
Frog = FindObjectOfType<Frog>();
CountDownLabel = (TextMesh) GameObject.Find ("CountDown").GetComponent<TextMesh>();
//Countdown
InvokeRepeating ("CountDown", 1f, 1f);
}
static void Main(string[] args)
{
try
{
Frog Goshko = new Frog("Goshko", 10, "male");
Frog Dimitrur = new Frog("Dimitur",6, "male");
Frog Minka = new Frog("Minka", 3, "female");
Dog Rex = new Dog("Rex", 1, "male");
Dog Hunter = new Dog("Hunter", 5, "male");
Dog Blondie = new Dog("Blondie",3,"female");
Kitten Puxy = new Kitten ("Puxy" , 2);
Kitten Dazzy = new Kitten("Dazzy",5);
Kitten Tuffy = new Kitten("Tuffy", 4);
TomCat Tom = new TomCat("Tom", 4);
TomCat Djeramaia = new TomCat("Djeramaia", 1);
TomCat Virgin = new TomCat("Virgin",7);
IList<Animal> animals = new List<Animal>
{
Goshko,Dimitrur,Minka,Rex,Hunter,Blondie,Puxy,Dazzy,Tuffy,Tom,Djeramaia,Virgin
};
Goshko.ProduceSound();
Rex.ProduceSound();
Puxy.ProduceSound();
Tom.ProduceSound();
double catsAverageAge = animals
.Where(animal => animal is Cat)
.Average(cat => cat.Age);
double dogsAverageAge = animals
.Where(animal => animal is Dog)
.Average(dog => dog.Age);
double frogsAverageAge = animals
.Where(animal => animal is Frog)
.Average(frog => frog.Age);
Console.WriteLine("Frogs average age is: {0:F2}", frogsAverageAge);
Console.WriteLine("Dogs average age is: {0:F2}", dogsAverageAge);
Console.WriteLine("Cats average age is: {0:F2}", catsAverageAge);
}
catch (ArgumentOutOfRangeException ae)
{
Console.WriteLine(ae.Message);
}
catch (ArgumentNullException ae)
{
Console.WriteLine(ae.Message);
}
catch (ArgumentException ae)
{
Console.WriteLine(ae.Message);
}
}
public static Frog[] FillFrogArr()
{
var frogArr = new Frog[rnd.Next(5, 21)];
for (int i = 0; i < frogArr.Length; i++)
{
frogArr[i] = new Frog(GetRandomName(), rnd.Next(1, 16), rnd.Next(1, 3) == 1 ? true : false);
}
return frogArr;
}
static void Main()
{
Dog[] dogs = new Dog[]
{
new Dog(5, "Sharo", 'm'),
new Dog(8, "Johnny", 'm'),
new Dog(2, "Brian", 'm')
};
Frog[] frogs = new Frog[]
{
new Frog(1, "Kikirica", 'f'),
new Frog(2, "Jaborana", 'f')
};
Cat[] cats = new Cat[]
{
new Cat(5, "Pisana", 'f'),
new Cat(3, "Stefka", 'f'),
new Cat(7, "Roshko", 'm'),
new Cat(4, "Maca", 'f')
};
Kitten[] kittens = new Kitten[]
{
new Kitten(1, "Pisana"),
new Kitten(1, "Belosnejka"),
new Kitten(1, "Cecka")
};
Tomcat[] tomcats = new Tomcat[]
{
new Tomcat(14, "Tom"),
new Tomcat(7, "Rich"),
new Tomcat(3, "Roshko 2")
};
Console.WriteLine("Average age of Dogs: {0}", AverageAge(dogs));
Console.WriteLine("Average age of Frogs: {0}", AverageAge(frogs));
Console.WriteLine("Average age of Cats: {0}", AverageAge(cats));
Console.WriteLine("Average age of Kittens: {0}", AverageAge(kittens));
Console.WriteLine("Average age of Tomcats: {0}", AverageAge(tomcats));
Console.WriteLine("Sounds:");
Console.Write("\tThe dog says: ");
dogs[0].MakeSound();
Console.Write("\tThe frog says: ");
frogs[0].MakeSound();
Console.Write("\tThe cat says: ");
cats[0].MakeSound();
Console.Write("\tThe kitten says: ");
kittens[0].MakeSound();
Console.Write("\tThe tomcat says: ");
tomcats[0].MakeSound();
}
static void Main()
{
// Animal an00 = new Animal("animal", 99, Sex.Male); //- it is not possible to initialize Animal - the class is abstract
Frog an01 = new Frog("Jabka", 1, Sex.Female);
Console.Write("sound of a frog is:");
an01.Makesound();
Dog an02 = new Dog("Balkan", 5, Sex.Male);
Console.Write("sound of a dog is:");
an02.Makesound();
Cat an03 = new Cat("Muro", 2, Sex.Male); // Cat could be male or female
Cat an04 = new Cat("Izabela", 4, Sex.Female); // Cat could be male or female
Console.Write("sound of a cat is:");
an04.Makesound();
Kitten an05 = new Kitten("Chochi", 2); //Kitten is alwais female
Console.WriteLine("Kitten's sex is {0}", an05.Sex);
Console.Write("sound of a kitten is:");
an05.Makesound();
// an05.Sex = Sex.Male; //It is not possible to access/change the sex of an Animal
Tomcat an06 = new Tomcat("Gosho", 5);
Console.WriteLine("Tomcat's sex is {0}", an06.Sex);
Console.Write("sound of a tomcat is:");
an06.Makesound();
Dog an07 = new Dog("Lara", 8, Sex.Female);
Dog an08 = new Dog("Sharo", 3, Sex.Male);
Frog an09 = new Frog("Cermit", 2, Sex.Male);
Kitten an10 = new Kitten("Suzi", 5);
Tomcat an11 = new Tomcat("Tom", 2);
Frog[] frogs = { an01, an09 };
Console.WriteLine("The average age of frogs is {0:f2}", Animal.AverageAge(frogs)); //Static method in class Animal
Console.WriteLine("The average age of frogs calculated by lambda is {0:f2}",frogs.Average(x=>x.Age));
Dog[] dogs = { an02, an07, an08};
Console.WriteLine("The average age of dogs is {0:f2}", Animal.AverageAge(dogs));
Console.WriteLine("The average age of dogs calculated by lambda is {0:f2}", dogs.Average(x => x.Age));
Cat[] allKindOfCats = { an03, an04, an05, an06, an10, an11};
Console.WriteLine("The average age of all kind of cats is {0:f2}", Animal.AverageAge(allKindOfCats));
Console.WriteLine("The average age of all kin of cats calculated by lambda is {0:f2}", allKindOfCats.Average(x => x.Age));
Console.WriteLine();
//Mix array
Animal[] allAnimals = { an01,an02,an03, an04,an05, an06, an07, an08, an09, an10, an11};
//split mixed aray to groups
var groups = from kind in allAnimals
group kind by kind.GetType() into species
select species;
//calculate and print average age by groups
foreach (var item in groups)
{
Console.WriteLine("Kind ->{0, -10}; Average age ->{1:f2}", item.Key.Name, item.Average(x => x.Age));
}
}
static void Main()
{
Animal[] dogArray = new Animal[5];
dogArray[0] = new Dog("Sharo", 4, "male");
dogArray[1] = new Dog("Rex", 1, "male");
dogArray[2] = new Dog("Lasi", 10, "male");
dogArray[3] = new Dog("Djinka", 3, "female");
dogArray[4] = new Dog("Princess", 2, "female");
foreach (var animal in dogArray)
{
Console.WriteLine(animal);
}
var dogArrayAvg = dogArray.Average(d => d.Age);
Console.WriteLine("Average dog age: {0:F2}{1}",dogArrayAvg, Environment.NewLine);
Console.WriteLine();
Cat[] catArray = new Cat[5];
catArray[0] = new Kitten("Mici", 3);
catArray[1] = new Tomcat("Tom", 5);
catArray[2] = new Kitten("Grozdanka", 2);
catArray[3] = new Tomcat("Grozdan", 10);
catArray[4] = new Kitten("Micana", 7);
foreach (var cat in catArray)
{
Console.WriteLine(cat);
}
var catArrayAvg = catArray.Average(c => c.Age);
Console.WriteLine("Average cat age: {0:F2}{1}",catArrayAvg, Environment.NewLine);
Console.WriteLine();
Frog[] frogArray = new Frog[5];
frogArray[0] = new Frog("Kyrmit", 4, "male");
frogArray[1] = new Frog("Kyrmita", 2, "female");
frogArray[2] = new Frog("Kyrmin", 6, "male");
frogArray[3] = new Frog("Kyrmina", 3, "female");
frogArray[4] = new Frog("Kyrtin", 8, "male");
foreach (var frog in frogArray)
{
Console.WriteLine(frog);
}
var frogArrayAvg = frogArray.Average(f => f.Age);
Console.WriteLine("Average frog age: {0:F2}{1}", frogArrayAvg, Environment.NewLine);
Console.WriteLine();
}
public void SetSpeedForFrog(Frog frog)
{
int scoreMod = frog.score + 10;
if (scoreMod > 50) {
scoreMod = 50;
}
print ("scoreMod:" + scoreMod);
int speedMod = Random.Range (scoreMod / 2, scoreMod);
_speed = speedMod / 2;
_speed+= 4;
print ("spawned with speed: " + _speed + " with speedMod: " + speedMod);
}
public static void Main()
{
Dog[] dogsArray = new Dog[]
{
new Dog("Burk", Sex.Male, 2),
new Dog("Charlie", Sex.Male, 2),
new Dog("Sara", Sex.Female, 3),
new Dog("Abra", Sex.Female, 7)
};
Frog[] frogsArray = new Frog[]
{
new Frog("Froggy", Sex.Male, 2),
new Frog("Lyagushka", Sex.Male, 5),
new Frog("Kvak", Sex.Female, 4),
new Frog("Plyok", Sex.Female, 1)
};
Cat[] catsArray = new Cat[]
{
new Cat("Maca", Sex.Female, 3),
new Cat("Pisan", Sex.Male, 4),
new Cat("Kotarana", Sex.Female, 2),
new Cat("Hurry", Sex.Male, 7)
};
Kitten[] kittensArray = new Kitten[]
{
new Kitten("Pisana", 4),
new Kitten("Macka", 2),
new Kitten("Blacky", 6),
new Kitten("Browny", 5)
};
Tomcat[] tomcatsArray = new Tomcat[]
{
new Tomcat("Coder", 2),
new Tomcat("Dicky", 9),
new Tomcat("Speedy", 4),
new Tomcat("Sleepy", 7)
};
Console.WriteLine("The average age of all dos is {0} years.", Animal.AverageAge(dogsArray));
Console.WriteLine("The average age of all frogs is {0} years.", Animal.AverageAge(frogsArray));
Console.WriteLine("The average age of all cats is {0} years.", Animal.AverageAge(catsArray));
Console.WriteLine("The average age of all kittens is {0} years.", Animal.AverageAge(kittensArray));
Console.WriteLine("The average age of all tomcats is {0} years.", Animal.AverageAge(tomcatsArray));
}
// generates random animals
public static Animal GetRandomAnimal()
{
seed = rnd.Next(1, 5);
switch (seed)
{
case 1:
Sex s = sexes[rnd.Next(0, sexes.Length)]; // get random sex for the animal
// give the animal a name corresponding to its sex
string name = s == Sex.Male ? names[rnd.Next(0, names.Length)] : femNames[rnd.Next(0, femNames.Length)];
// create new animal
var doge = new Dog(name, s, (uint)rnd.Next(0, maxAge));
// add his years in the years array
animalsCountAndAges[0] += doge.Age;
animalsCountAndAges[1]++;
// return the new animal
return doge;
case 2:
Sex frogS = sexes[rnd.Next(0, sexes.Length)];
string frogName = frogS == Sex.Male ? names[rnd.Next(0, names.Length)] : femNames[rnd.Next(0, femNames.Length)];
var froge = new Frog(frogName, frogS, (uint)rnd.Next(0, maxAge));
animalsCountAndAges[2] += froge.Age;
animalsCountAndAges[3]++;
return froge;
case 3:
var kitty = new Kitten(femNames[rnd.Next(0, femNames.Length)], (uint)rnd.Next(0, maxAge));
animalsCountAndAges[4] += kitty.Age;
animalsCountAndAges[5]++;
return kitty;
case 4:
var tommy = new Tomcat(names[rnd.Next(0, names.Length)], (uint)rnd.Next(0, maxAge));
animalsCountAndAges[6] += tommy.Age;
animalsCountAndAges[7]++;
return tommy;
default: throw new ArgumentException("Invalid seed");
}
}
static void Main()
{
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Test The Animals...");
Console.ResetColor();
Console.WriteLine();
TomCat tomy = new TomCat("Tom", 3);
Console.WriteLine("TomCat - " + tomy);
tomy.ProduceSound();
Console.WriteLine();
Dog rex = new Dog("Rex", 5, Gender.Male);
Console.WriteLine("Dog - " + rex);
rex.ProduceSound();
Console.WriteLine();
Frog flip = new Frog("Flip", 1, Gender.Male);
Console.WriteLine("Frog - " + flip);
flip.ProduceSound();
Console.WriteLine();
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Average Age...");
Console.ResetColor();
Console.WriteLine();
List<Cat> listOfCats = new List<Cat>();
listOfCats.Add(new Cat("Joney", 5, Gender.Male));
listOfCats.Add(new Cat("Mike", 1, Gender.Male));
listOfCats.Add(new Cat("Simi", 5, Gender.Female));
double catsAverageAge = listOfCats.Average(x => x.Age);
Console.WriteLine("List Of Cats Average Age: {0}", catsAverageAge);
List<Dog> listOfDogs = new List<Dog>();
listOfDogs.Add(new Dog("Sharko", 3, Gender.Female));
listOfDogs.Add(new Dog("Foxy", 1, Gender.Female));
listOfDogs.Add(new Dog("Tommy", 5, Gender.Male));
double dogsAverageAge = listOfDogs.Average(x => x.Age);
Console.WriteLine("List Of Dogs Average Age: {0}", dogsAverageAge);
Console.WriteLine();
}
static void Main(string[] args)
{
_animalsArr = new Animal[5];
_animalsArr[0] = new Frog("Froggy", 3, 'm');
_animalsArr[1] = new Dog("Kudgo", 10, 'm');
_animalsArr[2] = new Kitten("Pussy", 3);
_animalsArr[3] = new Tomcat("Kotaran", 4);
_animalsArr[4] = new Dog("Big Bertha", 11, 'f');
foreach (var a in _animalsArr.GroupBy(x => x.GetType().Name))
{
Console.WriteLine("Animal: {0}\nAvarage Age: {1}\n",
a.Key, a.Select(x => x.Age).Average());
}
}
//This method checks whether the frog will crash in a vehicle. It's not optimised but works
public void CheckCrash(Frog frog, int n, int m)
{
if (frog.X >= this.Coll - 4 && frog.X <= this.Coll + m && frog.Y == this.Row + n)
{
//crashSound.Play();
frog.X = Console.BufferWidth / 2;
frog.Y = Console.BufferHeight - 4;
frog.LivesLeft--;
frog.Score -= 30;
if (frog.Score < 0)
{
frog.Score = 0;
}
frog.WasInSafeZone = false;
}
}
static void Main(string[] args)
{
Cat[] cats = new Cat[]
{
new Cat("Aira", 2, Sex.female),
new Cat("Roni", 6, Sex.male),
new Cat("Ketty", 3, Sex.female),
};
Console.WriteLine(Animal.AverageAge(cats));
Dog[] dogs = new Dog[]
{
new Dog("Rijko", 4, Sex.male),
new Dog("Roni", 5, Sex.male),
new Dog("Molly", 3, Sex.female),
};
Console.WriteLine(Animal.AverageAge(dogs));
Kitten[] kittens = new Kitten[]
{
new Kitten("Kremi", 3),
new Kitten("Maca", 1),
new Kitten("Murja", 8),
};
Console.WriteLine(Animal.AverageAge(kittens));
Tomcat[] tomcats = new Tomcat[]
{
new Tomcat("Rijka", 2),
new Tomcat("Bojka", 1),
new Tomcat("Sara", 10),
};
Console.WriteLine(Animal.AverageAge(tomcats));
Frog[] frogs = new Frog[]
{
new Frog("Ash", 1, Sex.female),
new Frog("Hrk", 1, Sex.female),
new Frog("JKl", 1, Sex.female),
};
Console.WriteLine(Animal.AverageAge(frogs));
}
static void Main(string[] args)
{
Dog firstDog = new Dog(2, "Sharo");
Dog secondDog = new Dog(6, "Djaro");
Dog thirdDog = new Dog(1, "Tobi");
Dog fourthDog = new Dog(5, "Roni");
Dog[] dogs = new Dog[]
{
firstDog, secondDog, thirdDog, fourthDog
};
Console.WriteLine("The average age of the dogs is: {0}", Animal.GetAverageAge(dogs));
firstDog.MakeSound();
Console.WriteLine();
Cat firstCat = new Kitten(1, "Kitty");
Cat secondCat = new Tomcat(2, "Bojko");
Cat thirdCat = new Cat(4, "Myrzel", "male");
Cat[] cats = new Cat[]
{
firstCat,
secondCat,
thirdCat
};
Console.WriteLine("The average age of the cats is: {0}", Animal.GetAverageAge(cats));
Console.WriteLine();
Console.WriteLine("The kitten's name is: {0} ", firstCat.GetName());
Console.WriteLine("The kitten's age is: {0}", firstCat.GetAge());
Console.WriteLine("All kittens are {0}", firstCat.Sex);
firstCat.MakeSound();
Console.WriteLine();
Console.WriteLine("The tomcat's name is: {0}", secondCat.GetName());
Console.WriteLine("All tomcats are {0}", secondCat.Sex);
secondCat.MakeSound();
thirdCat.MakeSound();
Console.WriteLine();
Frog froggy = new Frog(22, "Prince");
froggy.MakeSound();
}
static void Main()
{
Dog[] dogArray = new Dog[10];
for (int i = 0; i < 10; i++)
{
dogArray[i] = new Dog(0, "Rover", "Male");
dogArray[i].SetRandomAge(0, 15);
}
Console.WriteLine("Average years of the Dog array: " + Animal.AverageAge(dogArray));
Console.WriteLine();
Frog[] frogArray = new Frog[10];
for (int i = 0; i < 10; i++)
{
frogArray[i] = new Frog(0, "Wib", "Male");
frogArray[i].SetRandomAge(0, 20);
}
Console.WriteLine("Average years of the Frog array: " + Animal.AverageAge(frogArray));
Console.WriteLine();
Cat[] catArray = new Cat[10];
for (int i = 0; i < 10; i++)
{
catArray[i] = new Cat(0, "Whiskers", "Male");
catArray[i].SetRandomAge(0, 22);
}
Console.WriteLine("Average years of the Cat array: " + Animal.AverageAge(catArray));
Console.WriteLine();
Tomcat[] tomcatArray = new Tomcat[10];
for (int i = 0; i < 10; i++)
{
tomcatArray[i] = new Tomcat(0, "Tom");
tomcatArray[i].SetRandomAge(0, 22);
}
Console.WriteLine("Average years of the Tomcat array: " + Animal.AverageAge(tomcatArray));
Console.WriteLine();
Kitten[] kittenArray = new Kitten[10];
for (int i = 0; i < 10; i++)
{
kittenArray[i] = new Kitten(0, "Felicity");
kittenArray[i].SetRandomAge(0, 22);
}
Console.WriteLine("Average years of the Kitten array: " + Animal.AverageAge(kittenArray));
Console.WriteLine();
}
static void Main()
{
Frog f1 = new Frog("Billy", 0.2, "m");
Dog d1 = new Dog("Liza", 4, "f");
Cat c1 = new Cat("Kotaksi", 2, "m");
Kitten k1 = new Kitten("Raya", 1);
Tomcat t1 = new Tomcat("Rijo", 2);
f1.ProduceSound();
d1.ProduceSound();
c1.ProduceSound();
k1.ProduceSound();
t1.ProduceSound();
Console.WriteLine();
Animal[] animals = new Animal[]
{
new Frog("Billy", 0.2, "m"),
new Dog("Liza", 4, "f"),
new Cat("Kotaksi", 2, "m"),
new Kitten("Raya", 1),
new Tomcat("Rijo", 2),
new Frog("Pesho", 2.1, "f"),
new Dog("Beti", 5.4, "f"),
new Cat("Kotka", 2, "f"),
new Kitten("Spaska", 4),
new Tomcat("Gosho", 3),
new Frog("Marmot", 4, "m"),
new Tomcat("Bizen", 0.5),
new Dog("India", 2.5, "f"),
};
animals.
GroupBy(animal => animal.GetType().Name).
Select(group => new
{
name = group.Key,
averageYears = group.Average(animal => animal.Age)
}).
ToList().
ForEach(group => Console.WriteLine("Group: {0}, average age: {1:F2} years!", group.name, group.averageYears));
}
private static void ReadAndCreateAnimal(List <Animal> animals, string animalType)
{
var animalTokens = Console.ReadLine().Split(' ');
string name = animalTokens[0];
int age = int.Parse(animalTokens[1]);
string gender = "Male";
if (animalTokens.Length == 3)
{
gender = animalTokens[2];
}
switch (animalType)
{
case "Cat":
var cat = new Cat(name, age, gender);
animals.Add(cat);
break;
case "Dog":
var dog = new Dog(name, age, gender);
animals.Add(dog);
break;
case "Frog":
var frog = new Frog(name, age, gender);
animals.Add(frog);
break;
case "Tomcat":
var tomcat = new Tomcat(name, age);
animals.Add(tomcat);
break;
case "Kitten":
var kitten = new Kitten(name, age);
animals.Add(kitten);
break;
default:
break;
}
}
private static void ReadAndCreateAnimal(List <Animal> animals, string animalType)
{
string[] tokens = Console.ReadLine().Split();
string name = tokens[0];
int age = int.Parse(tokens[1]);
string gender = null;
if (tokens.Length == 3)
{
gender = tokens[2];
}
switch (animalType)
{
case "Cat":
var cat = new Cat(name, age, gender);
animals.Add(cat);
break;
case "Dog":
var dog = new Dog(name, age, gender);
animals.Add(dog);
break;
case "Frog":
var frog = new Frog(name, age, gender);
animals.Add(frog);
break;
case "Kitten":
var kittens = new Kitten(name, age);
animals.Add(kittens);
break;
case "Tomcat":
var tomcat = new Tomcat(name, age);
animals.Add(tomcat);
break;
default:
throw new ArgumentException("Invalid input!");
}
}
// Unity calls this function when our coin touches any other object
// If the player touched us, the coin should vanish and score go up
private void OnCollisionEnter2D(Collision2D collision)
{
// Check if the thing we touched was the Frog
Frog playerScript = collision.collider.GetComponent <Frog>();
// If the thing we touched HAS a player script, that means
// it IS a player, so....
if (playerScript)
{
// We hit the player!
// Add to the score based on our value
scoreObject.AddScore(bugValue);
// Destroy the gameObject that this script is attached to
// (the coin)
Destroy(gameObject);
}
}
private static void ReadAndCreateAnimals(List <Animal> animals, string animalType)
{
var splittedInput = Console.ReadLine()
.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
var name = splittedInput[0];
var age = int.Parse(splittedInput[1]);
string gender = null;
if (splittedInput.Length == 3)
{
gender = splittedInput[2];
}
switch (animalType)
{
case "Cat":
Cat cat = new Cat(name, age, gender);
animals.Add(cat);
break;
case "Dog":
Dog dog = new Dog(name, age, gender);
animals.Add(dog);
break;
case "Frog":
Frog frog = new Frog(name, age, gender);
animals.Add(frog);
break;
case "Kitten":
Kitten kitten = new Kitten(name, age);
animals.Add(kitten);
break;
case "Tomcat":
Tomcat tomcat = new Tomcat(name, age);
animals.Add(tomcat);
break;
default:
throw new ArgumentException("Invalid input!");
}
}
private static void AddAnimal(List <Animal> animals, string input, string[] tokens)
{
if (tokens.Length < 3)
{
throw new ArgumentException("Invalid input!");
}
string animalType = input;
string name = tokens[0];
int age = int.Parse(tokens[1]);
string gender = tokens[2];
Animal animal;
switch (animalType)
{
case "Cat":
animal = new Cat(name, age, gender);
break;
case "Dog":
animal = new Dog(name, age, gender);
break;
case "Frog":
animal = new Frog(name, age, gender);
break;
case "Kitten":
animal = new Kitten(name, age);
break;
case "Tomcat":
animal = new Tomcat(name, age);
break;
default:
throw new ArgumentException("Invalid input!");
break;
}
animals.Add(animal);
}
private static void GetAnimal(out Animal animal)
{
animal = null;
string animalsType = Console.ReadLine();
if (animalsType == "Beast!")
{
return;
}
string[] tokens = Console.ReadLine().Split(" ");
string name = tokens[0];
int age = int.Parse(tokens[1]);
string gender = tokens[2];
switch (animalsType)
{
case "Dog":
animal = new Dog(name, age, gender);
break;
case "Frog":
animal = new Frog(name, age, gender);
break;
case "Cat":
animal = new Cat(name, age, gender);
break;
case "Kitten":
animal = new Kitten(name, age);
break;
case "Tomcat":
animal = new Tomcat(name, age);
break;
default:
throw new ArgumentException("Invalid input!");
}
}
// Unity calls this function automatically
// when our spikes touch any other object
private void OnCollisionEnter2D(Collision2D collision)
{
// Check if the thing that we collided with
// is the player (aka has a Player script)
Frog playerScript = collision.collider.GetComponent <Frog>();
// Only do something if the thing we ran into
// was in fact the player
// aka playerScript is not null
if (playerScript != null)
{
// We DID hit the player!
// Save the score using our score object reference
scoreObject.SaveScore();
// Load the next level
SceneManager.LoadScene(sceneToLoad);
}
}
private void OnTriggerEnter2D(Collider2D collision)
{
if (collision.gameObject.CompareTag("m_frog"))
{
GameManager.instance.score += scoreGain;
Frog frog = Frog.instance;
Vector2 newPos = frog.transform.position;
frog.startingPos = newPos;
camera.transform.position = new Vector3(camera.transform.position.x, camera.orthographicSize * 2, camera.transform.position.z);
for (int i = 0; i < eraseList.Count; i++)
{
Destroy(eraseList[i]);
}
for (int i = 0; i < activateList.Count; i++)
{
activateList[i].SetActive(true);
}
Destroy(gameObject);
}
}
public void allinactive()
{
Cat.SetActive(false);
Cow.SetActive(false);
Kancil.SetActive(false);
Deer.SetActive(false);
Bearblack.SetActive(false);
Foxblack.SetActive(false);
Frogblack.SetActive(false);
Bear.SetActive(false);
Fox.SetActive(false);
Frog.SetActive(false);
Mice.SetActive(false);
Deer.SetActive(false);
Catblack.SetActive(false);
Miceblack.SetActive(false);
Kancilblack.SetActive(false);
Cowblack.SetActive(false);
Deerblack.SetActive(false);;
}
public void DropFox()
{
float Distance = Vector3.Distance(Fox.transform.position, Foxblack.transform.position);
if (Distance < 50)
{
Fox.transform.position = Foxblack.transform.position;
ScoreDrag.totalscore += 20;
clickSound.Play();
Foxb = false;
check2++;
// level2++;
Frog.SetActive(true);
check++;
}
else
{
Fox.transform.position = FoxiniPost;
}
}
static void Main()
{
Dog[] dogs = new Dog[]
{
new Dog("Sharo", 5, Gender.Male),
new Dog("Rex", 8, Gender.Male)
};
Frog[] frogs = new Frog[]
{
new Frog("Grogo", 1, Gender.Male),
new Frog("Frogina", 3, Gender.Female)
};
Kitten[] kittens = new Kitten[]
{
new Kitten("Fluffy", 5),
new Kitten("Patrisha", 2)
};
Tomcat[] tomcats = new Tomcat[]
{
new Tomcat("Tom", 3),
new Tomcat("Johnny", 5)
};
List <Animal[]> animals = new List <Animal[]>();
animals.Add(dogs);
animals.Add(frogs);
animals.Add(kittens);
animals.Add(tomcats);
Console.WriteLine("Average age by animal type:");
foreach (var animalArray in animals)
{
Console.WriteLine("{0}:\t{1};",
animalArray[0].GetType(), //assumes non-empty arrays
GetAverageAge(animalArray));
}
}
public static Animal Create(string animalType, string[] elements)
{
string name = elements[0];
int age = int.Parse(elements[1]);
string gender = elements[2];
Animal animal = null;
if (animalType == "Dog")
{
animal = new Dog(name, age, gender);
}
else if (animalType == "Frog")
{
animal = new Frog(name, age, gender);
}
else if (animalType == "Cat")
{
animal = new Cat(name, age, gender);
}
else if (animalType == "Kitten")
{
if (gender != "Female")
{
throw new ArgumentException("Invalid input!");
}
animal = new Kitten(name, age);
}
else if (animalType == "Tomcat")
{
if (gender != "Male")
{
throw new ArgumentException("Invalid input!");
}
animal = new Tomcat(name, age);
}
return(animal);
}
static void Main(string[] args)
{
FrogBuilder builder = new FrogBuilder();
builder.buildFrog();
Frog first = builder.getFrog();
builder.buildFrog();
Frog second = builder.getFrog();
builder.buildFrog();
Frog third = builder.getFrog();
Console.WriteLine("Enter a distance in inches");
decimal inches = Convert.ToDecimal(Console.ReadLine());
Console.WriteLine("The first frog {1}: traveled the distance in {0} minutes", first.getTimeTraveled(inches).ToString("0.0000"), first.getName());
Console.WriteLine("The second frog {1}: traveled the distance in {0} minutes", second.getTimeTraveled(inches).ToString("0.0000"), second.getName());
Console.WriteLine("The first frog {1}: traveled the distance in {0} minutes", third.getTimeTraveled(inches).ToString("0.0000"), third.getName());
Console.ReadKey();
}
public static void Main()
{
Dog sharo = new Dog("Sharo", 8, "male");
Cat mimi = new Cat("Mimi", 4, "female");
Frog kvak = new Frog("Kvaki", 3, "male");
Kitten pisi = new Kitten("Pisi", 3);
Tomcat tomi = new Tomcat("Tom", 5);
List <Animal> animals = new List <Animal> {
sharo, mimi, kvak, pisi, tomi
};
foreach (var animal in animals)
{
Console.WriteLine(animal);
animal.ProduceSound();
Console.WriteLine("_____________________");
}
Console.WriteLine("Their average of age is {0} years.", animals.Average(a => a.Age));
}
static void Main()
{
Frog kerm=new Frog("Kerm",4,"male");
kerm.ProduceSound();
Tomcat tommy=new Tomcat("Tommy",8,"");
tommy.ProduceSound();
Animal[] animals=new Animal[]{new Dog("SnoopDog",5,"male"),new Kitten("Mia",2,""),new Tomcat("Tom",5,""),new Frog("Kermit",12,"male"),new Dog("Max",1,"male"), };
foreach (var animal in animals)
{
Console.WriteLine(animal);
}
//AvarageAgeOfAll\\
double avarageOfAll= animals.Average(animal => animal.Age);
Console.WriteLine("Avarage: {0}",avarageOfAll);
//AvarageOfDog\\
double avarageOfDog = animals.OfType<Dog>().Average(dog => dog.Age);
Console.WriteLine("Avarage Dog:{0}",avarageOfDog);
//AvarageOfCat\\
double avarageOfCat = animals.OfType<Cat>().Average(cat => cat.Age);
Console.WriteLine("Avarage Cat:{0}",avarageOfCat);
}
public static void Main()
{
var kittenTea = new Kitten("Tea", 2);
var tomcatRoko = new Tomcat("Roko", 4);
var kittenCeca = new Kitten("Ceca", 1);
var dogBalkan = new Dog("Balkan", 3, Gender.Male);
var dogSara = new Dog("Sara", 2, Gender.Female);
var frogKermit = new Frog("Kermit", 1, Gender.Male);
var frogCarlotta = new Frog("Carlotta", 2, Gender.Female);
var animals = new Animal[] { kittenTea, tomcatRoko, kittenCeca, dogBalkan, dogSara, frogKermit, frogCarlotta };
Animal.PrintAverageAge(animals);
foreach (var animal in animals)
{
animal.ProduceSound();
}
}
private void CreateFrog()
{
this.frog = SerpentUtils.Instantiate <Frog>(this.frogPrefab, this.mazeController.transform);
if (this.frog == null)
{
return;
}
this.frog.CreatureDied += FrogDied;
this.frog.SetUp(this, this.mazeController);
// Randomize frog placement.
int x = 0;
int y = 0;
if (UnityEngine.Random.Range(0, 2) == 0)
{
// top or bottom edge
if (UnityEngine.Random.Range(0, 2) == 0)
{
y = this.mazeController.Maze.Height - 1;
}
// avoid spawning right in the corners
x = 1 + UnityEngine.Random.Range(0, this.mazeController.Maze.Width - 1);
}
else
{
// left or right edge
if (UnityEngine.Random.Range(0, 2) == 0)
{
x = this.mazeController.Maze.Width - 1;
}
// avoid spawning right in the corners
y = 1 + UnityEngine.Random.Range(0, this.mazeController.Maze.Height - 1);
}
PlaceCreature(this.frog, x, y, Direction.N);
}
static void Main()
{
Dog[] dogs = new Dog[]
{
new Dog("Sharo", 5, Gender.Male),
new Dog("Rex", 8, Gender.Male)
};
Frog[] frogs = new Frog[]
{
new Frog("Grogo", 1, Gender.Male),
new Frog("Frogina", 3, Gender.Female)
};
Kitten[] kittens = new Kitten[]
{
new Kitten("Fluffy", 5),
new Kitten("Patrisha", 2)
};
Tomcat[] tomcats = new Tomcat[]
{
new Tomcat("Tom", 3),
new Tomcat("Johnny", 5)
};
List<Animal[]> animals = new List<Animal[]>();
animals.Add(dogs);
animals.Add(frogs);
animals.Add(kittens);
animals.Add(tomcats);
Console.WriteLine("Average age by animal type:");
foreach (var animalArray in animals)
{
Console.WriteLine("{0}:\t{1};",
animalArray[0].GetType(), //assumes non-empty arrays
GetAverageAge(animalArray));
}
}
// Use this for initialization
void Start()
{
cc = GetComponent <CharacterController>();
cs = FindObjectOfType <CollisionScript>();
rb = GetComponent <Rigidbody>();
col = GetComponent <CapsuleCollider>();
rotationTarget = new Quaternion();
animators = GetComponentsInChildren <Animator>();
foreach (Animator animator in animators)
{
animator.speed = 5;
}
clones = FindObjectsOfType <Clone>();
foreach (Clone clone in clones)
{
clone.gameObject.SetActive(false);
}
invincibleTimer = invincibleTime;
frog = GetComponentInChildren <Frog>();
frog.gameObject.SetActive(false);
gm = FindObjectOfType <GameManager>();
}
static void Main(string[] args)
{
while (true)
{
var animalType = Console.ReadLine();
if (animalType == "Beast!")
{
break;
}
var animalInfo = Console.ReadLine().Split(' ', StringSplitOptions.RemoveEmptyEntries);
var animalName = animalInfo[0];
var animalAge = int.Parse(animalInfo[1]);
var animal = new Animal("NoName", 0, "f****t");
try
{
switch (animalType)
{
case "Cat": animal = new Cat(animalName, animalAge, animalInfo[2]); break;
case "Dog": animal = new Dog(animalName, animalAge, animalInfo[2]); break;
case "Frog": animal = new Frog(animalName, animalAge, animalInfo[2]); break;
case "Kitten": animal = new Kitten(animalName, animalAge); break;
case "Tomcat": animal = new Tomcat(animalName, animalAge); break;
default:
throw new ArgumentException("Invalid input!");
}
Console.WriteLine(animal);
}
catch (ArgumentException argex)
{
Console.WriteLine(argex.Message);
}
}
}
private static void TestAnimals()
{
Random rng = new Random();
var doge = new Dog("Doge", 5, Gender.Male);
// chance a dog to find a stick is about 80% :D
Console.WriteLine(doge.FollowTheStick(rng.Next(10)));
Console.WriteLine(doge.FollowTheStick(rng.Next(10)));
Console.WriteLine(doge.FollowTheStick(rng.Next(10)));
Console.WriteLine(doge.FollowTheStick(rng.Next(10)));
Console.WriteLine(doge.Sound());
var otherDoge = new Dog("OtherDoge", 0, Gender.Male);
Console.WriteLine(otherDoge.FollowTheStick(rng.Next(10)));
otherDoge.Sound();
PrintLine();
var froggy = new Frog("Froggy", 2, Gender.Female, "green");
Console.WriteLine(froggy.Sound());
Console.WriteLine(froggy.Talk());
Console.WriteLine(froggy.Sound());
PrintLine();
var cat = new Cat("Stamat", 3, Gender.Male);
Console.WriteLine(cat.Play(rng.Next(10)));
var kitty = new Kitty("Kitty", 1);
Console.WriteLine(kitty.Play(rng.Next(10)));
kitty.IncreaseAge(1);
var tomcat = new Tomcat("TomCat", 2);
Console.WriteLine(tomcat.Play(rng.Next(10)));
PrintLine();
}
protected void GenerateLevel(List <List <int> > layout)
{
//0 = burner
//19 = butter_before
//3 = counter_dark
//4 = counter_light
//20 = cutting_board
//23 = flour
//21 = garnished_plate
//22 = pan
//24 = sink
//10 = black_tile
//11 = white_tile
rowCount = layout.Count;
for (int i = 0; i < layout.Count; i++)
{
List <int> currentRow = layout[i];
for (int j = 0; j < currentRow.Count; j++)
{
Vector2 tilePosition = new Vector2(j * SacreBleuGame._instance._tileWidth, i * SacreBleuGame._instance._tileWidth);
entities.Add(TileManager.Instance.CreateTile(currentRow[j], tilePosition));
}
}
foreach (GameObject g in entities)
{
if (g != null && g._tag.Equals("Cutting Board"))
{
_frogStartingPosition = g._position;
_frog = new Frog(new Vector2(g._position.X + 64, g._position.Y + 28), SacreBleuGame._instance.frogTexture, 0.015f, 0.75f);
}
else if (g != null && g._tag.Equals("Goal"))
{
_goal = (Goal)g;
}
}
}
private static void ReadAndCreateAnimal(List <Animal> animals, string animal)
{
string[] animalArgs = Console.ReadLine().Split();
string animalName = animalArgs[0];
int animalAge = int.Parse(animalArgs[1]);
string animalGender = animalArgs[2];
switch (animal)
{
case "Cat":
Cat cat = new Cat(animalName, animalAge, animalGender);
animals.Add(cat);
break;
case "Frog":
Frog frog = new Frog(animalName, animalAge, animalGender);
animals.Add(frog);
break;
case "Dog":
Dog dog = new Dog(animalName, animalAge, animalGender);
animals.Add(dog);
break;
case "Kitten":
Kitten kitten = new Kitten(animalName, animalAge);
animals.Add(kitten);
break;
case "Tomcat":
Tomcat tomcat = new Tomcat(animalName, animalAge);
animals.Add(tomcat);
break;
default:
throw new ArgumentException("Invalid input!");
}
}
static void Main()
{
Animal[] animalsList =
{
new Dog("Rex", 7, Sex.Female),
new Cat("Dogfood", 2, Sex.Female),
new Cat("Bloodhound", 6, Sex.Male),
new Tomcat("Kitty", 102),
new Tomcat("Kitty Junior", 3)
};
//average age
var animalGroups =
from animal in animalsList
group animal by animal.GetType().Name into groups
select new
{
Name = groups.Key,
AverageAge =
(from anim in groups
select anim.Age).Average()
};
//print average age
foreach (var group in animalGroups)
{
Console.WriteLine("{0} average age: {1}", group.Name, group.AverageAge);
}
Console.WriteLine("\nSome tests");
//Kitten
Kitten kitkat = new Kitten("Kitkat", 6);
Console.WriteLine("The kitten says:");
kitkat.Talk();
Console.WriteLine("{0} is {1}", kitkat.Name, kitkat.Sex);
//Frog
Frog princess = new Frog("Princess", 21, Sex.Female);
Console.WriteLine("The frog says:");
princess.Talk();
}
static void Main()
{
var tom = new Tomcat("Tommas", 3, "m");
var bruno = new Tomcat("Bruno", 1, "male");
var spike = new Dog("Spike", 4, "m");
var dog = new Dog("Бенджи", 4, "male");
var frog = new Frog("Veso", 1, "female");
var anotherFrog = new Frog("Sasho", 2, "m");
var kitten = new Kitten("Kote", 2, "female");
var cat = new Cat("Маца", 5, "f");
var anotherKitty = new Kitten("Penka", 4, "female");
Animal[] animals = new Animal[]
{
tom, dog, frog, kitten, cat, spike, bruno, anotherFrog, anotherKitty
};
foreach (var kind in animals.GroupBy(animal => animal.GetType()))
{
double averageAge = kind.Average(animal => (double)animal.Age);
Console.WriteLine("{0} - average age: {1}", kind.Key, averageAge);
}
}
public void AddTrinket()
{
var frog = new Frog {
Id = 5, Name = "Kermit", DateOfBirth = DateTime.Today
};
var basket = new TestBasket <Frog>(frog);
Assert.Empty(basket.Trinkets);
var num = DateTime.Now.Millisecond;
var date = DateTime.Today;
var str = Guid.NewGuid().ToString();
basket.AddTrinket("one", num);
basket.AddTrinket("two", date);
basket.AddTrinket("three", str);
Assert.Equal(3, basket.Trinkets.Count);
Assert.Equal(num, basket.Trinkets["one"]);
Assert.Equal(date, basket.Trinkets["two"]);
Assert.Equal(str, basket.Trinkets["three"]);
}
static void Main()
{
var tom = new Tomcat("Tommas", 3, "m");
var bruno = new Tomcat("Bruno", 1, "male");
var spike = new Dog("Spike", 4, "m");
var dog = new Dog("Бенджи", 4, "male");
var frog = new Frog("Veso", 1, "female");
var anotherFrog = new Frog("Sasho", 2, "m");
var kitten = new Kitten("Kote", 2, "female");
var cat = new Cat("Маца", 5, "f");
var anotherKitty = new Kitten("Penka", 4, "female");
Animal[] animals = new Animal[]
{
tom, dog, frog, kitten, cat, spike, bruno, anotherFrog, anotherKitty
};
foreach (var kind in animals.GroupBy(animal => animal.GetType()))
{
double averageAge = kind.Average(animal => (double)animal.Age);
Console.WriteLine("{0} - average age: {1}", kind.Key, averageAge);
}
}
// checks collision with frog and sticks frog to platform if so
public override void CollisionCheck(Frog frog)
{
bool collided = false;
foreach (MovingObject movingObj in GetList)
{
if (movingObj.State is AboveWaterState)
{
if (SplashKit.BitmapCollision(movingObj.Bitmap, movingObj.Position, SplashKit.BitmapNamed("frog"), frog.Position))
{
collided = true;
frog.Stick(movingObj);
// if frog has half his body over the platforms edge, collision is set to false
collided &= frog.X + 25 >= movingObj.X && frog.X + 25 <= movingObj.X + movingObj.Width;
}
}
}
// kills frog when frog is in the river and is not on a platform
if (!collided && frog.Y.Equals(_y))
{
frog.Splash();
}
}
static void Main(string[] args)
{
Cats[] cat = new Cats[]
{
new Tomcat("Ivan", 11),
new Kitten("Ivanka", 12),
};
Dog[] dog = new Dog[]
{
new Dog("Kuchence", 15, Gender.Female),
new Dog("Kuche", 19, Gender.Male)
};
Frog[] frog = new Frog[] {
new Frog("Jabka", 2, Gender.Female),
new Frog("Jabok", 15, Gender.Male)
};
Console.WriteLine(Average(cat));
foreach (var item in cat)
{
Console.Write(item.ToString() + " .");
item.Sound();
}
Console.WriteLine();
Console.WriteLine(Average(dog));
foreach (var item in dog)
{
Console.Write(item.ToString() + " .");
item.Sound();
}
Console.WriteLine();
Console.WriteLine(Average(frog));
foreach (var item in frog)
{
Console.Write(item.ToString() + " .");
item.Sound();
}
}
static void Main(string[] args)
{
//Create a hierarchy Dog, Frog, Cat, Kitten, Tomcat and define useful
//constructors and methods. Dogs, frogs and cats are Animals. All animals
//can produce sound (specified by the ISound interface). Kittens and
//tomcats are cats. All animals are described by age, name and sex. Kittens
//can be only female and tomcats can be only male. Each animal produces a specific
//sound. Create arrays of different kinds of animals and calculate the average
//age of each kind of animal using a static method (you may use LINQ).
//Make some animals and test their properties
Kitten kitty = new Kitten(3, "Kitty");//the sex is aways female
Console.WriteLine(kitty.Name + "-" + kitty.Age + "-" + kitty.sex);
kitty.ProduceSound();
Tomkat tom = new Tomkat(5, "Tom");//the sex is aways male
Console.WriteLine(tom.Name + "-" + tom.Age + "-" + tom.sex);
tom.ProduceSound();
Dog doggy = new Dog(8, "Doggy", Sex.male);
Console.WriteLine(doggy.Name + "-" + doggy.Age + "-" + doggy.sex);
doggy.ProduceSound();
Frog froggy = new Frog(1, "Froggy", Sex.female);
Console.WriteLine(froggy.Name + "-" + froggy.Age + "-" + froggy.sex);
froggy.ProduceSound();
//Make array with diferent animals and calculate the average age for every animal type in the array
Animal[] animals = { kitty, tom, froggy, doggy,
new Kitten(4, "Keit"),
new Tomkat(5, "Tomas"),
new Dog(11, "Rex", Sex.male),
new Frog(3, "Curmit", Sex.male) };
CalculateEveryAnimalAverageAge(animals);
}
private void OnMouseDown()
{
GameObject startPanel = GameObject.Find("StartPanel");
if (startPanel)
{
return;
} // check if paused (ie startpanel active)
if (!Button.selectedDefender)
{
return;
}
int defenderCost = Button.selectedDefender.GetComponent <Defender>().startCost;
Frog frog = Button.selectedDefender.GetComponent <Frog>();
if (frog)
{
GameObject frogButton = GameObject.Find("FrogButton");
SpriteRenderer frogSpriteRenderer = frogButton.GetComponent <SpriteRenderer>();
if (frogSpriteRenderer.sprite == null)
{
return;
}
else
{
spawnDefender();
frogSpriteRenderer.sprite = null;
}
}
// NB enums are viewed as static so are accessed by the class not an instance.
if (starDisplay.UseStars(defenderCost) == StarDisplay.status.SUCCESS)
{
spawnDefender();
}
}
static void Main()
{
Frog[] frogs = new Frog[5]
{
new Frog("Jabcho", 1, Sex.male),
new Frog("Jabok", 2, Sex.male),
new Frog("Jabka", 3, Sex.female),
new Frog("Jabchocho", 1, Sex.male),
new Frog("Jabkaka", 3, Sex.female)
};
Dog[] dogs = new Dog[6]
{
new Dog("Balkan", 4, Sex.male),
new Dog("Mecho", 5, Sex.male),
new Dog("Rex", 8, Sex.female),
new Dog("Sharo", 1, Sex.male),
new Dog("Puffi", 3, Sex.female),
new Dog("Gudjo", 5, Sex.male)
};
Cat[] cats = new Cat[8]
{
new Cat("Mats", 1, Sex.male),
new Cat("Lucky", 2, Sex.female),
new Kitten("Jabka", 3),
new Cat("Kotancho", 2, Sex.male),
new Kitten("Pissi", 3),
new Tomcat("Lucky", 4),
new Tomcat("Kotak", 4),
new Tomcat("MatsMats", 3)
};
PrintToConsole(frogs);
PrintToConsole(dogs);
PrintToConsole(cats);
}
static void Main(string[] args)
{
Frog Broasca1 = new Frog(1, "B1", "female");
Frog Broasca2 = new Frog(2, "B2", "female");
Frog Broasca3 = new Frog(3, "B3", "male");
Frog Broasca4 = new Frog(2, "B4", "female");
Frog[] Broaste = new[] { Broasca1, Broasca2, Broasca3, Broasca4 };
Dog Caine1 = new Dog(4, "C1", "male");
Dog Caine2 = new Dog(1, "C2", "male");
Dog Caine3 = new Dog(10, "C3", "female");
Dog Caine4 = new Dog(7, "C4", "female");
Dog[] Caini = new[] { Caine1, Caine2, Caine3, Caine4 };
Cat Pisica1 = new Kitten(2, "P1", "female"); // e corect?
Cat Pisica2 = new Kitten(6, "P2", "female");
Cat Pisica3 = new Kitten(5, "P3", "female");
Cat Pisica4 = new Kitten(1, "P4", "female");
Cat Motan1 = new Tomcat(5, "M1", "male");
Cat Motan2 = new Tomcat(5, "M2", "male");
Cat Motan3 = new Tomcat(7, "M3", "male");
Cat Motan4 = new Tomcat(6, "M4", "male");
Cat[] Pisici = new[] { Motan1, Motan2, Motan3, Motan4, Pisica1, Pisica2, Pisica3, Pisica4 };
AverageAgeOfAnimals.PrintBroasteAvaregeAge();
AverageAgeOfAnimals.PrintDogAvaregeAge();
AverageAgeOfAnimals.PrintKittenAvaregeAge();
AverageAgeOfAnimals.PrintTomcatAvaregeAge();
Console.WriteLine(55);
Console.ReadKey();
}
private static void ReadAndCreateAnimal(List <Animal> animals, string animalType)
{
string[] tokens = Console.ReadLine().Split();
NotEmptyValidation(tokens);
switch (animalType)
{
case "Cat":
Cat cat = new Cat(tokens[0], int.Parse(tokens[1]), tokens[2]);
animals.Add(cat);
break;
case "Dog":
Dog dog = new Dog(tokens[0], int.Parse(tokens[1]), tokens[2]);
animals.Add(dog);
break;
case "Frog":
Frog frog = new Frog(tokens[0], int.Parse(tokens[1]), tokens[2]);
animals.Add(frog);
break;
case "Kitten":
Kitten kitten = new Kitten(tokens[0], int.Parse(tokens[1]), tokens[2]);
animals.Add(kitten);
break;
case "Tomcat":
Tomcat tomcat = new Tomcat(tokens[0], int.Parse(tokens[1]), tokens[2]);
animals.Add(tomcat);
break;
default:
throw new ArgumentException("Invalid input!");
break;
}
}
public override Animal ReadJson(JsonReader reader, Type objectType, Animal existingValue,
bool hasExistingValue, JsonSerializer serializer)
{
var animalObj = JObject.Load(reader);
var type = (string)animalObj["type"];
Animal instance;
switch (type)
{
case "Tiger":
instance = new Tiger();
break;
case "Frog":
instance = new Frog();
break;
default:
instance = new Animal();
break;
}
serializer.Populate(animalObj.CreateReader(), instance);
return(instance);
}
public void TestAnimalConstructor7_ThrowsException()
{
Frog frog = new Frog("Charlie", -12, true);
}
public void TestAnimalConstructor3()
{
Animal dog = new Frog("Caesar", 3, true);
Assert.AreEqual(true, dog.IsMale);
}
public void TestAnimalConstructor2()
{
Animal frog = new Frog("Charlie", 15, true);
Assert.AreEqual(15, frog.Age);
}
void Awake()
{
IsMoving = false;
frog = transform.parent.GetComponent<Frog>();
string handName = transform.name.Replace("Limb", "Hand");
handRenderer = transform.FindChild(handName).GetComponent<SpriteRenderer>();
originalSprite = handRenderer.sprite;
hand = transform.FindChild(handName+"Grab");
handGrabRenderer = hand.GetComponent<SpriteRenderer>();
grabSprite = handGrabRenderer.sprite;
backGrabSprite = (Sprite)frog.GetType().GetField(handName + "GrabBackSprite").GetValue(frog);
handGrabRenderer.sprite = null;
}
