public void Init()
{
duckFactory = new CountingDuckFactory();
//QuackCounter is Decorator Pattern
mallardDuck = duckFactory.CreateMallardDuck();
redheadDuck = duckFactory.CreateRedheadDuck();
duckCall = duckFactory.CreateDuckCall();
rubberDuck = duckFactory.CreateRubberDuck();
gooseDuck = new GooseAdapter(new Goose()); //Adapter Pattern
//Flock is Iterator Pattern
flockOfDucks = new Flock();
flockOfDucks.Add(redheadDuck);
flockOfDucks.Add(duckCall);
flockOfDucks.Add(rubberDuck);
flockOfDucks.Add(gooseDuck);
flockOfMallards = new Flock();
mallardOne = duckFactory.CreateMallardDuck();
mallardTwo = duckFactory.CreateMallardDuck();
mallardThree = duckFactory.CreateMallardDuck();
mallardFour = duckFactory.CreateMallardDuck();
flockOfMallards.Add(mallardOne);
flockOfMallards.Add(mallardTwo);
flockOfMallards.Add(mallardThree);
flockOfMallards.Add(mallardFour);
flockOfDucks.Add(flockOfMallards);
}
static void Main(string[] args)
{
// Abstract Factory
AbstractDuckFactory duckFactory = new CountingDuckQuackFactory();
// Abstract factory to create Strategy pattern wrapped in Decorator pattern
IQuackable mallardDuck = duckFactory.CreateMallardDuck();
IQuackable redheadDuck = duckFactory.CreateRedheadDuck();
IQuackable rubberDuck = duckFactory.CreateRubberDuck();
// Adapter pattern
IQuackable goose = new GooseAdapter(new Goose());
// Composite pattern
Flock flockOfDucks = new Flock();
flockOfDucks.Add(mallardDuck);
flockOfDucks.Add(redheadDuck);
flockOfDucks.Add(rubberDuck);
Flock flockOfMallards = new Flock();
flockOfMallards.Add(duckFactory.CreateMallardDuck());
flockOfMallards.Add(duckFactory.CreateMallardDuck());
flockOfMallards.Add(duckFactory.CreateMallardDuck());
flockOfMallards.Add(duckFactory.CreateMallardDuck());
flockOfMallards.Add(duckFactory.CreateMallardDuck());
duckCall(mallardDuck);
duckCall(redheadDuck);
duckCall(rubberDuck);
duckCall(goose);
// Flock of Mallards
Console.WriteLine("\nA flock of Mallards quacking ...");
flockOfMallards.Quack();
// Flock of mixed ducks
Console.WriteLine("\nA flock of mixed ducks quacking ...");
flockOfDucks.Quack();
// Altogether now
Console.WriteLine("\nEntire flock quacking ...");
flockOfDucks.Add(flockOfMallards);
flockOfDucks.Quack();
Console.WriteLine($"Number of duck quacks = {QuackCounter.GetQuackCount()}");
Console.ReadKey();
}
public void Simulate(AbstractDuckFactory factory)
{
var flockOfDucks = new Flock();
flockOfDucks.Add(factory.CreateMallardDuck());
flockOfDucks.Add(factory.CreateRedheadDuck());
flockOfDucks.Add(factory.CreateDuckCall());
flockOfDucks.Add(factory.CreateRubberDuck());
flockOfDucks.Add(new QuackCounter(new GooseAdapter(new Goose())));
var flockOfMallards = new Flock();
for (int i = 0; i < 4; i++)
{
flockOfMallards.Add(factory.CreateMallardDuck());
}
flockOfDucks.Add(flockOfMallards);
"Duck Simulator with Observer\n--------------------------------".P();
var quackologist = new Quackologist();
flockOfDucks.RegisterObserver(quackologist);
flockOfDucks.Quack();
"Mallard Simulator\n--------------------------------".P();
flockOfMallards.Quack();
"--------------------------------\nThe ducks quacked {0} times".P(QuackCounter.GetQuacks());
}
private void Simulate(AbstractDuckFactory duckFactory)
{
Flock flockOfDucks = new Flock
{
duckFactory.CreateRedheadDuck(),
duckFactory.CreateDuckCall(),
duckFactory.CreateRubberDuck(),
new GooseAdapter(new Geese.Goose())
};
Flock flockOfMallards = new Flock
{
duckFactory.CreateMallardDuck(),
duckFactory.CreateMallardDuck(),
duckFactory.CreateMallardDuck(),
duckFactory.CreateMallardDuck(),
};
Console.WriteLine("\nDuck Simulator: With Observer");
Quackologist quackologist = new Quackologist();
flockOfDucks.Subscribe(quackologist);
flockOfDucks.Add(flockOfMallards);
Console.WriteLine("\nDuck Simulator: Whole Flock Simulator");
Simulate(flockOfDucks);
Console.WriteLine("\nDuck Simulator: Mallard Flock Simulator");
Simulate(flockOfMallards);
Console.WriteLine("\nThe ducks quacked {0} times", QuackCounter.Count);
}
public void Compound_Observer()
{
DuckSimulator sim = new DuckSimulator();
Flock flockDucks = new Flock();
IDuckFactory duckFactory = new DuckCounterFactory();
flockDucks.Add(duckFactory.CreateMallardDuck());
flockDucks.Add(duckFactory.CreateRubberDuck());
flockDucks.Add(duckFactory.CreateRedheadDuck());
flockDucks.Add(duckFactory.CreateDuckCall());
flockDucks.Add(new GooseAdapter(new Goose()));
flockDucks.RegisterObservers(new QuackologistObserver());
sim.Simulate(flockDucks);
Assert.AreEqual(4, QuackCounter.GetQuackCount());
}
void Simulate(AbstractDuckFactory duckFactory)
{
Quackable mallardDuck = duckFactory.CreateMallardDuck();
Quackable redHeadDuck = duckFactory.CreateRedHeadDuck();
Quackable duckCall = duckFactory.CreateDuckCall();
Quackable rubberDuck = duckFactory.CreateRubberDuck();
Quackable gooseAdapter = duckFactory.CreateGeese();// new GeeseAdapter(new Geese());
Flock duckFlock = new Flock();
duckFlock.Add(mallardDuck);
duckFlock.Add(redHeadDuck);
duckFlock.Add(duckCall);
duckFlock.Add(rubberDuck);
duckFlock.Add(gooseAdapter);
Flock mallardFlock = new Flock();
mallardFlock.Add(duckFactory.CreateMallardDuck());
mallardFlock.Add(duckFactory.CreateMallardDuck());
mallardFlock.Add(duckFactory.CreateMallardDuck());
mallardFlock.Add(duckFactory.CreateMallardDuck());
//again add the mallard to duck flock
duckFlock.Add(mallardFlock);
//Quackalogist qmallard = new Quackalogist();
//MallardDuck malldck = new MallardDuck();
//malldck.RegisterObservable(qmallard);
//Simulate(malldck);
//Quackalogist quackalogist = new Quackalogist();
//Quackable mallardDuckDec = new QuackCounter(new MallardDuck());
//mallardDuckDec.RegisterObservable(quackalogist);
//Simulate(mallardDuckDec);
Quackalogist quackalogistFlock = new Quackalogist();
duckFlock.RegisterObservable(quackalogistFlock);
Console.WriteLine("\nPrinting duckflock+ mallardflock");
Simulate(duckFlock);
Console.WriteLine("\nPrinting mallardflock");
//mallardFlock.RegisterObservable(quackalogistFlock);
Simulate(mallardFlock);
Console.WriteLine(QuackCounter.GetQuackCounter());
}
public void Simulate(AbstractDuckFactory duckFactory)
{
IQuackable mallardDuck = duckFactory.CreateMallardDuck();
IQuackable redheadDuck = duckFactory.CreateRedheadDuck();
IQuackable duckCall = duckFactory.CreateDuckCall();
IQuackable rubberDuck = duckFactory.CreateRubberDuck();
IQuackable gooseDuck = new GooseAdapter(new Goose());
Console.WriteLine("\nDuck Simulator: With Abstract Factory, Composite - Flocks");
Flock flockOfDucks = new Flock();
flockOfDucks.Add(redheadDuck);
flockOfDucks.Add(duckCall);
flockOfDucks.Add(rubberDuck);
flockOfDucks.Add(gooseDuck);
Flock flockOfMallards = new Flock();
IQuackable mallardOne = duckFactory.CreateMallardDuck();
IQuackable mallardTwo = duckFactory.CreateMallardDuck();
IQuackable mallardThree = duckFactory.CreateMallardDuck();
IQuackable mallardFour = duckFactory.CreateMallardDuck();
flockOfMallards.Add(mallardOne);
flockOfMallards.Add(mallardTwo);
flockOfMallards.Add(mallardThree);
flockOfMallards.Add(mallardFour);
flockOfDucks.Add(flockOfMallards);
Console.WriteLine("\nDuck Simulator: Whole Flock Simulation");
Simulate(flockOfDucks);
Console.WriteLine("\nDuck Simulator: Mallard Flock Simulation");
Simulate(flockOfMallards);
Console.WriteLine("\nDuck Simulator: With Observer");
Quackologist quackologist = new Quackologist();
flockOfDucks.RegisterObserver(quackologist);
Simulate(flockOfDucks);
Console.WriteLine("The ducks quacked " + QuackCounter.NumberOfQuacks + " times.");
}
private static void Simulate(AbstractDuckFactory duckFactory, AbstractGooseFactory gooseFactory)
{
IQuackable mallardDuck = duckFactory.CreateMallardDuck();
IQuackable readheadDuck = duckFactory.CreateReadheadDuck();
IQuackable duckCall = duckFactory.CreateDuckCall();
IQuackable rubberDuck = duckFactory.CreateRubberDuck();
IQuackable gooseDuck = new GooseAdapter(gooseFactory.CreateGoose());
Console.WriteLine("\nDuck Simulator: With Composite - Flocks");
var flockOfDucks = new Flock();
flockOfDucks.Add(mallardDuck);
flockOfDucks.Add(readheadDuck);
flockOfDucks.Add(duckCall);
flockOfDucks.Add(rubberDuck);
flockOfDucks.Add(gooseDuck);
var flockOfMallards = new Flock();
IQuackable mallard_1 = duckFactory.CreateMallardDuck();
IQuackable mallard_2 = duckFactory.CreateMallardDuck();
IQuackable mallard_3 = duckFactory.CreateMallardDuck();
IQuackable mallard_4 = duckFactory.CreateMallardDuck();
flockOfMallards.Add(mallard_1);
flockOfMallards.Add(mallard_2);
flockOfMallards.Add(mallard_3);
flockOfMallards.Add(mallard_4);
flockOfDucks.Add(flockOfMallards);
Console.WriteLine("\nDuck Simulator: With Observer");
var quackologist = new Quackologist();
flockOfDucks.RegisterObserver(quackologist);
Console.WriteLine("\nDuck Simulator: Whole Flock Simulation");
Simulate(flockOfDucks);
Console.WriteLine("\nDuck Simulator: Mallard Flock Simulation");
Simulate(flockOfMallards);
Console.WriteLine($"The ducks quacked {QuackCounter.GetQuacks()} times");
}
private static void generateDucksAndRunSimulation(AbstractDuckFactory abstractDuckFactory, AbstractGooseFactory abstractGooseFactory)
{
IQuackable redheadDuck = abstractDuckFactory.CreateRedheadDuck();
IQuackable duckCall = abstractDuckFactory.CreateDuckCall();
IQuackable rubberDuck = abstractDuckFactory.CreateRubberDuck();
IQuackable gooseDuck = abstractGooseFactory.CreateGoose();
Flock flockOfDucks = new Flock();
flockOfDucks.Add(redheadDuck);
flockOfDucks.Add(duckCall);
flockOfDucks.Add(rubberDuck);
flockOfDucks.Add(gooseDuck);
Flock flockOfMallards = new Flock();
// Create a little family of mallards here
IQuackable mallardDuck1 = abstractDuckFactory.CreateMallardDuck();
IQuackable mallardDuck2 = abstractDuckFactory.CreateMallardDuck();
IQuackable mallardDuck3 = abstractDuckFactory.CreateMallardDuck();
IQuackable mallardDuck4 = abstractDuckFactory.CreateMallardDuck();
flockOfMallards.Add(mallardDuck1);
flockOfMallards.Add(mallardDuck2);
flockOfMallards.Add(mallardDuck3);
flockOfMallards.Add(mallardDuck4);
// Also add the flock of mallards to the flock of ducks - They are ducks in the end too!
flockOfDucks.Add(flockOfMallards);
Console.WriteLine("\nDuck Simulator: Whole Flock Simulation with observer");
IObserver quackologist = new Quackologist();
flockOfDucks.RegisterObserver(quackologist);
simulate(flockOfDucks);
Console.WriteLine("\nDuck Simulator: Mallard Flock Simulation");
simulate(flockOfMallards);
Console.WriteLine("The ducks quacked " + QuackCounterDecorator.GetNumberOfQuacks() + " times");
}
public void Compound_Composite()
{
DuckSimulator sim = new DuckSimulator();
Flock flockDucks = new Flock();
IDuckFactory duckFactory = new DuckFactory();
flockDucks.Add(duckFactory.CreateMallardDuck());
flockDucks.Add(duckFactory.CreateMallardDuck());
flockDucks.Add(duckFactory.CreateMallardDuck());
flockDucks.Add(duckFactory.CreateMallardDuck());
Flock flockRubberDucks = new Flock();
flockRubberDucks.Add(duckFactory.CreateRubberDuck());
flockRubberDucks.Add(duckFactory.CreateRubberDuck());
flockRubberDucks.Add(duckFactory.CreateRubberDuck());
flockDucks.Add(flockRubberDucks);
sim.Simulate(flockDucks);
}
public void Simulate()
{
IQuackableObservable mallardDuck = factory.CreateMallardDuck();
IQuackableObservable redheadDuck = factory.CreateRubberDuck();
IQuackableObservable duckCall = factory.CreateDuckCall();
IQuackableObservable rubberDuck = factory.CreateRubberDuck();
IQuackableObservable gooseDuck = new GooseAdapter(new Goose());
Flock flockOfDucks = new Flock();
flockOfDucks.Add(mallardDuck);
flockOfDucks.Add(redheadDuck);
flockOfDucks.Add(duckCall);
flockOfDucks.Add(rubberDuck);
Quackologist q = new Quackologist();
flockOfDucks.RegisterObserver(q);
mallardDuck.RegisterObserver(q);
Console.WriteLine("-----Whole Ducks quack-----\n");
Simulate(flockOfDucks);
Console.WriteLine("--------Duck Simulator----------");
Simulate(mallardDuck);
Simulate(redheadDuck);
Simulate(duckCall);
Simulate(rubberDuck);
Simulate(gooseDuck);
Console.WriteLine("Quacks Count:" + QuackCounter.quackCount);
}
private void Simulate(AbstractDuckFactory duckFactory)
{
IQuackable redheadDuck = duckFactory.CreateRedheadDuck();
IQuackable duckCall = duckFactory.CreateDuckCall();
IQuackable rubberDuck = duckFactory.CreateRubberDuck();
IQuackable gooseDuck = new GooseAdapter(new Goose());
Flock flockOfDucks = new Flock();
flockOfDucks.Add(redheadDuck);
flockOfDucks.Add(duckCall);
flockOfDucks.Add(rubberDuck);
flockOfDucks.Add(gooseDuck);
Flock flockOfMallards = new Flock();
IQuackable mallardOne = duckFactory.CreateMallardDuck();
IQuackable mallardTwo = duckFactory.CreateMallardDuck();
IQuackable mallardThree = duckFactory.CreateMallardDuck();
IQuackable mallardFour = duckFactory.CreateMallardDuck();
flockOfMallards.Add(mallardOne);
flockOfMallards.Add(mallardTwo);
flockOfMallards.Add(mallardThree);
flockOfMallards.Add(mallardFour);
flockOfDucks.Add(flockOfMallards);
Console.WriteLine($"{System.Environment.NewLine}Duck Simulator: With Observer");
Quackologist quackologist = new Quackologist();
flockOfDucks.RegisterObserver(quackologist);
Simulate(flockOfDucks);
Console.WriteLine($"{System.Environment.NewLine}The ducks quacked {QuackCounter.NumberOfQuacks} times");
}
private void simulate(AbstractDuckFactory duckFactory)
{
IQuack redheadDuck = duckFactory.CreateRedheadDuck();
IQuack duckCall = duckFactory.CreateDuckCall();
IQuack rubberDuck = duckFactory.CreatRubberDuck();
IQuack gooseDuck = new GooseAdapter(new Goose());
Flock flockOfDucks = new Flock();
flockOfDucks.Add(redheadDuck);
flockOfDucks.Add(duckCall);
flockOfDucks.Add(rubberDuck);
flockOfDucks.Add(gooseDuck);
Flock flockOfMallards = new Flock();
IQuack mallardOne = duckFactory.CreateMallardDuck();
IQuack mallardTwo = duckFactory.CreateMallardDuck();
IQuack mallardThree = duckFactory.CreateMallardDuck();
IQuack mallardFour = duckFactory.CreateMallardDuck();
flockOfMallards.Add(mallardOne);
flockOfMallards.Add(mallardTwo);
flockOfMallards.Add(mallardThree);
flockOfMallards.Add(mallardFour);
flockOfDucks.Add(flockOfMallards);
Console.WriteLine("\r\nDuck Simulator: With Observer");
Quacklogist quacklogist = new Quacklogist();
flockOfDucks.RegisterObserver(quacklogist);
simulate(flockOfDucks);
Console.WriteLine("The ducks quacked " + QuackCounter.GetQuacks + " times");
}
public void ParseContext(List <Transform> context)
{
List <Transform> friendlies = context.Where(item => item.parent.gameObject == transform.parent.gameObject).ToList();
List <Transform> enemies = context.Where(item => item.parent.gameObject != transform.parent.gameObject).ToList();
if (friendlies.Count < enemies.Count)
{
time += Time.deltaTime;
}
else
{
time = 0;
}
if (time > 1)
{
Flock enemyFlock = enemies.First().GetComponentInParent <Flock>();
gameObject.SetActive(false);
enemyFlock.Add(transform);
deleted = true;
}
}
