public static void Main(string[] args)
{
///////////////////////////////////////////////////////
// Instantiate nodes to populate animal shelter queue
///////////////////////////////////////////////////////
AnimalNode <string> catPreference = new AnimalNode <string>("cat");
AnimalNode <string> dogPreference = new AnimalNode <string>("dog");
// Instantiate and populate animal shelter queue
AnimalShelter <string> animalShelter = new AnimalShelter <string>(catPreference);
// Populate shelter with mix of dogs and cats
animalShelter.EnqueueAnimal(dogPreference);
animalShelter.EnqueueAnimal(dogPreference);
animalShelter.EnqueueAnimal(catPreference);
animalShelter.EnqueueAnimal(dogPreference);
animalShelter.EnqueueAnimal(dogPreference);
Console.WriteLine("");
Console.WriteLine($"Front: {animalShelter.Front.Value}");
Console.WriteLine($"Rear: {animalShelter.Rear.Value}");
Console.WriteLine("");
///////////////////////////////////////////
// Beginning of console app UI
///////////////////////////////////////////
Console.WriteLine("Please enter the animal you would like: dog or cat.");
try
{
// Take in user input
string pref = Console.ReadLine();
while (pref.ToLower() != "dog" && pref.ToLower() != "cat")
{
Console.WriteLine("Please choose either 'dog' or 'cat'. Or press 'X' to exit the program.");
pref = Console.ReadLine();
if (pref.ToLower() == "x")
{
Environment.Exit(0);
}
}
// Instantiate animal node with value input by user
AnimalNode <string> preferredAnimal = new AnimalNode <string>(pref);
// Dequeue user's preferred type of animal and store in variable
//AnimalNode<string> dequeuedAnimal = DequeueAnimal(animalShelter, preferredAnimal);
AnimalNode <string> dequeuedAnimal = animalShelter.DequeueAnimal(preferredAnimal);
Console.WriteLine($"You've successfully gotten your new {dequeuedAnimal.Value} from the shelter!\n");
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
public AnimalNode Dequeue(AnimalType type)
{
AnimalNode ret = null;
switch(type)
{
case AnimalType.Cat:
ret = _headCat;
_headCat.Last.Next = _headCat.Next;
_headCat = _headCat.NextSame;
break;
case AnimalType.Dog:
ret = _headDog;
_headDog.Last.Next = _headDog.Next;
_headDog = _headDog.NextSame;
break;
}
if(ret == _head)
{
_head = _head.Next;
}
return ret;
}
public static AnimalNode ReadNode(StreamReader sr)
{
char ch;
do
{
ch = (char)sr.Read();
}while (Char.IsWhiteSpace(ch));
AnimalNode an = new AnimalNode();
while ((ch = (char)sr.Read()) != ',')
{
an.Question += ch;
}
if ((char)sr.Peek() != ',')
{
an.anYes = ReadNode(sr);
}
ch = (char)sr.Read();
if ((char)sr.Peek() != ')')
{
an.anNo = ReadNode(sr);
}
ch = (char)sr.Read(); // This is the closing parenthesis.
return(an);
}
private Animal DequeueType(Type type)
{
if (_tail is null)
{
throw new Exception("empty");
}
if (_tail.Animal.Type == type)
{
return(DequeueAny());
}
AnimalNode tmp = _tail;
while (tmp.Next != null)
{
if (tmp.Next.Animal.Type == type)
{
Animal a = tmp.Next.Animal;
tmp.Next = tmp.Next.Next;
return(a);
}
else
{
tmp = tmp.Next;
}
}
throw new Exception("not found");
}
public void TestShelterDeQ1()
{
Animal animal9 = new Animal(AnimalOption.Dog);
Animal wantedAnimal1 = new Animal(AnimalOption.Dog);
AnimalShelter shelter4 = new AnimalShelter(animal9);
AnimalNode received1 = shelter4.ShelterDequeue(wantedAnimal1);
Assert.Equal(AnimalOption.Dog, received1.AnimalValue.AnimalProp);
}
static void AskQuestion(ref AnimalNode an)
{
if (an.anYes != null) // Ask a question; get an answer.
{
Console.Write(an.Question + " ");
if (GetYesNo())
{
AskQuestion(ref an.anYes);
}
else
{
AskQuestion(ref an.anNo);
}
}
else // End of the line; time to wrap up this game.
{
Console.Write("Is it a " + an.Question + " (Yes/No)? ");
if (GetYesNo())
{
Console.WriteLine("I guessed it!");
}
else
{
Console.Write("What animal were you thinking of? ");
string strAnimal = Console.ReadLine();
Console.WriteLine("And what yes/no question might " +
"distinguish a " + strAnimal +
" from a " + an.Question + "? ");
string strQuestion = Console.ReadLine();
Console.Write("And what's the answer for a " +
strAnimal + " (Yes/No)? ");
bool bAnswer = GetYesNo();
AnimalNode anNewAnimal = new AnimalNode();
anNewAnimal.Question = strAnimal;
AnimalNode anNewQuestion = new AnimalNode();
anNewQuestion.Question = strQuestion;
if (bAnswer)
{
anNewQuestion.anYes = anNewAnimal;
anNewQuestion.anNo = an;
}
else
{
anNewQuestion.anYes = an;
anNewQuestion.anNo = anNewAnimal;
}
an = anNewQuestion;
}
}
}
public void TestShelterDeQ2()
{
Animal animal10 = new Animal(AnimalOption.Dog);
Animal wantedAnimal2 = new Animal(AnimalOption.Cat);
AnimalShelter shelter4 = new AnimalShelter(animal10);
AnimalNode received2 = shelter4.ShelterDequeue(wantedAnimal2);
Assert.Null(received2);
}
public void TestAnimalQDeQ2()
{
Animal dog2 = new Animal(AnimalOption.Dog);
AnimalQueue dog2Q = new AnimalQueue();
dog2Q.Enqueue(dog2);
AnimalNode dog1Node = dog2Q.Dequeue();
Assert.Null(dog2Q.Front);
}
public void TestAnimalQPeek1()
{
Animal dogPeek1 = new Animal(AnimalOption.Dog);
AnimalQueue dogPeek1Q = new AnimalQueue();
dogPeek1Q.Enqueue(dogPeek1);
AnimalNode dog1Node = dogPeek1Q.Peek();
AnimalOption type4 = dog1Node.AnimalValue.AnimalProp;
Assert.Equal(AnimalOption.Dog, type4);
}
public void TestAnimalQEnQ1()
{
Animal dogGeorge = new Animal(AnimalOption.Dog);
AnimalQueue georgeQ = new AnimalQueue();
georgeQ.Enqueue(dogGeorge);
AnimalNode georgeNode = georgeQ.Dequeue();
AnimalOption type1 = georgeNode.AnimalValue.AnimalProp;
Assert.Equal(AnimalOption.Dog, type1);
}
public void TestAnimalQDeQ1()
{
Animal dog1 = new Animal(AnimalOption.Dog);
AnimalQueue dog1Q = new AnimalQueue();
dog1Q.Enqueue(dog1);
AnimalNode dog1Node = dog1Q.Dequeue();
AnimalOption type2 = dog1Node.AnimalValue.AnimalProp;
Assert.Equal(AnimalOption.Dog, type2);
}
public void TestAnimalQPeek2()
{
Animal dogPeek2 = new Animal(AnimalOption.Dog);
AnimalQueue dogPeek2Q = new AnimalQueue();
dogPeek2Q.Enqueue(dogPeek2);
dogPeek2Q.Dequeue();
AnimalNode dog2Node = dogPeek2Q.Peek();
Assert.Null(dog2Node);
}
public void CanReturnNullWhenTryingToDequeueFromEmptyQueue()
{
// Arrange
AnimalNode <string> preference = new AnimalNode <string>("cat");
AnimalShelter <string> animalShelter = new AnimalShelter <string>();
// Act
AnimalNode <string> dequeuedAnimal = animalShelter.DequeueAnimal(preference);
// Assert
Assert.Null(dequeuedAnimal);
}
public void CanReturnPreferredAnimal()
{
// Arrange
AnimalNode <string> catPreference = new AnimalNode <string>("cat");
AnimalShelter <string> animalShelter = new AnimalShelter <string>(catPreference);
// Act
AnimalNode <string> dequeuedAnimal = animalShelter.DequeueAnimal(catPreference);
// Assert
Assert.Equal("cat", dequeuedAnimal.Value);
}
public void TestShelterEnQ1()
{
Animal animal1 = new Animal(AnimalOption.Dog);
Animal animal1A = new Animal(AnimalOption.Dog);
AnimalShelter shelter1 = new AnimalShelter(animal1);
shelter1.ShelterEnqueue(animal1A);
AnimalNode shelterAnimalNode1 = shelter1.AnimalQueue1.Rear;
AnimalOption type6 = shelterAnimalNode1.AnimalValue.AnimalProp;
Assert.Equal(AnimalOption.Dog, type6);
}
public void TestAnimalQEnQ2()
{
Animal dogBob = new Animal(AnimalOption.Dog);
Animal catBetty = new Animal(AnimalOption.Cat);
AnimalQueue newQ2 = new AnimalQueue();
newQ2.Enqueue(dogBob);
newQ2.Enqueue(catBetty);
AnimalNode newQ2Rear = newQ2.Rear;
Assert.Equal(AnimalOption.Cat, newQ2Rear.AnimalValue.AnimalProp);
}
public void TestAnimalQEnQ3()
{
Animal catKitty = new Animal(AnimalOption.Cat);
Animal dogLarry = new Animal(AnimalOption.Dog);
Animal catJenny = new Animal(AnimalOption.Cat);
AnimalNode kittyNode = new AnimalNode(catKitty);
AnimalQueue newQ3 = new AnimalQueue(kittyNode);
newQ3.Enqueue(dogLarry);
newQ3.Enqueue(catJenny);
AnimalNode newQ3Rear = newQ3.Rear;
Assert.Equal(AnimalOption.Cat, newQ3Rear.AnimalValue.AnimalProp);
}
public void TestShelterEnQ2()
{
Animal animal2 = new Animal(AnimalOption.Dog);
Animal animal3 = new Animal(AnimalOption.Cat);
Animal animal4 = new Animal(AnimalOption.Cat);
AnimalShelter shelter2 = new AnimalShelter(animal2);
shelter2.ShelterEnqueue(animal3);
shelter2.ShelterEnqueue(animal4);
AnimalNode shelterAnimalNode2 = shelter2.AnimalQueue1.Rear;
AnimalOption type7 = shelterAnimalNode2.AnimalValue.AnimalProp;
Assert.Equal(AnimalOption.Cat, type7);
}
public void CanReturnNullIfNeitherDogNorCatPassedInAsPreferredAnimal()
{
// Arrange
AnimalNode <string> badPreference = new AnimalNode <string>("bird");
AnimalNode <string> legitPreference = new AnimalNode <string>("cat");
AnimalShelter <string> animalShelter = new AnimalShelter <string>();
animalShelter.EnqueueAnimal(legitPreference);
// Act
AnimalNode <string> dequeuedAnimal = animalShelter.DequeueAnimal(badPreference);
// Assert
Assert.Null(dequeuedAnimal);
}
public Animal DequeueAny()
{
if (_tail is null)
{
throw new Exception("emtpy");
}
Animal a = _tail.Animal;
_tail = _tail.Next;
if (_tail is null)
{
_head = null;
}
return(a);
}
public void TestAnimalQDeQ3()
{
Animal dog3 = new Animal(AnimalOption.Dog);
Animal cat1 = new Animal(AnimalOption.Cat);
Animal cat2 = new Animal(AnimalOption.Cat);
AnimalNode puppyNode = new AnimalNode(dog3);
AnimalQueue animal1Q = new AnimalQueue(puppyNode);
animal1Q.Enqueue(cat1);
animal1Q.Enqueue(cat2);
AnimalNode junk1Node = animal1Q.Dequeue();
AnimalNode checkNode = animal1Q.Dequeue();
AnimalOption type3 = checkNode.AnimalValue.AnimalProp;
Assert.Equal(AnimalOption.Cat, type3);
}
public void TestShelterEnQ3()
{
Animal animal5 = new Animal(AnimalOption.Dog);
Animal animal6 = new Animal(AnimalOption.Cat);
Animal animal7 = new Animal(AnimalOption.Dog);
Animal animal8 = new Animal(AnimalOption.Dog);
AnimalShelter shelter3 = new AnimalShelter(animal5);
shelter3.ShelterEnqueue(animal6);
shelter3.ShelterEnqueue(animal7);
shelter3.ShelterEnqueue(animal8);
AnimalNode shelterAnimalNode3 = shelter3.AnimalQueue1.Rear;
AnimalOption type8 = shelterAnimalNode3.AnimalValue.AnimalProp;
Assert.Equal(AnimalOption.Dog, type8);
}
public void TestAnimalQPeek3()
{
Animal dogPeek3 = new Animal(AnimalOption.Dog);
Animal catPeek1 = new Animal(AnimalOption.Cat);
AnimalNode puppyNode2 = new AnimalNode(dogPeek3);
AnimalQueue animalPeek3Q = new AnimalQueue(puppyNode2);
animalPeek3Q.Enqueue(dogPeek3);
animalPeek3Q.Dequeue();
animalPeek3Q.Dequeue();
animalPeek3Q.Enqueue(catPeek1);
AnimalNode animal3Node = animalPeek3Q.Peek();
AnimalOption type5 = animal3Node.AnimalValue.AnimalProp;
Assert.Equal(AnimalOption.Cat, type5);
}
public AnimalNode Dequeue()
{
var ret = _head;
if(_head == _headDog)
{
_headDog = _headDog?.NextSame;
}
else
{
_headCat = _headCat?.NextSame;
}
_head = _head?.Next;
return ret;
}
private void TraverseTree(AnimalNode node)
{
Console.WriteLine();
if (node == null)
{
ConsoleWrite("Uh, I don't know about the animal - it's not in my database.");
}
else if (node.HasResult)
{
Console.Write($"The answer is: {node.Result}. Am I right [Y/N]? ");
var isYes = IsYes();
Console.WriteLine();
ConsoleWrite(isYes ? "I won! :)" : "Oh no.. looks like I need to learn more..");
}
else
{
Console.Write($"{node.Question} [Y/N]? ");
TraverseTree(IsYes() ? node.MatchedNode : node.UnmatchedNode);
}
}
public void Enque(Animal a)
{
if (_head is null)
{
_head = new AnimalNode()
{
Animal = a
};
_tail = _head;
}
else
{
var n = new AnimalNode()
{
Animal = a
};
_head.Next = n;
_head = n;
}
}
public void TestShelterDeQ3()
{
Animal animal11 = new Animal(AnimalOption.Dog);
Animal animal12 = new Animal(AnimalOption.Cat);
Animal animal13 = new Animal(AnimalOption.Cat);
Animal animal14 = new Animal(AnimalOption.Dog);
Animal wantedAnimal3 = new Animal(AnimalOption.Cat);
Animal wantedAnimal4 = new Animal(AnimalOption.Dog);
Animal wantedAnimal5 = new Animal(AnimalOption.Dog);
AnimalShelter shelter5 = new AnimalShelter(animal11);
shelter5.ShelterEnqueue(animal12);
shelter5.ShelterEnqueue(animal13);
shelter5.ShelterEnqueue(animal14);
shelter5.ShelterDequeue(wantedAnimal3);
shelter5.ShelterDequeue(wantedAnimal4);
shelter5.ShelterDequeue(wantedAnimal5);
AnimalNode stillInShelter = shelter5.AnimalQueue1.Front;
Assert.Equal(AnimalOption.Cat, stillInShelter.AnimalValue.AnimalProp);
}
public void Enqueue(AnimalNode node)
{
if(_head == null)
{
_head = node;
}
else
{
var current = _head;
AnimalNode lastSame = current.AnimalType == node.AnimalType ? current : null;
while (current.Next != null)
{
current = current.Next;
if (current.AnimalType == node.AnimalType)
{
lastSame = current;
}
}
current.Next = node;
node.Last = current;
if (lastSame != null)
{
lastSame.NextSame = node;
}
}
if(node.AnimalType == AnimalType.Cat && _headCat == null)
{
_headCat = node;
}
else if(node.AnimalType == AnimalType.Dog && _headDog == null)
{
_headDog = node;
}
}
// Start is called before the first frame update
void Start()
{
occupied = new List <AnimalNode>();
vacant = new List <AnimalNode>();
for (int i = 0; i < worldSize; i++)
{
for (int j = 0; j < worldSize; j++)
{
vacant.Add((AnimalNode)nodes[i, j]);
}
}
for (int i = 0; i < amountOfAnimals; i++)
{
int random = Random.Range(0, vacant.Count);
AnimalNode animalNode = vacant[random];
animalNode.animal = true;
occupied.Add(animalNode);
vacant.RemoveAt(random);
animalNode.Spawn();
}
}
static void Main()
{
string strFilename = "GuessTheAnimal.txt";
AnimalNode anRoot;
try
{
StreamReader sr = new StreamReader(strFilename);
anRoot = AnimalNode.ReadNode(sr);
sr.Close();
}
catch
{
anRoot = new AnimalNode();
anRoot.Question = "cat";
}
do
{
// Start playing.
Console.Write("Think of an animal and press Enter.");
Console.ReadLine();
AskQuestion(ref anRoot);
// Save the file.
StreamWriter sw = new StreamWriter(strFilename);
anRoot.WriteNode(sw, 0);
sw.Close();
// Possibly play again.
Console.Write("Would you like to play again? ");
}while (GetYesNo());
}
