void Start()
{
dir = GameObject.FindGameObjectWithTag ("Director").GetComponent<Director>();
bouldersCanSpawn = false;
timer = 0.0f;
}
public static void Main()
{
Director director = new Director();
Unit terranUnit = director.ConstructUnit(new TerranBuilder());
Unit zergUnit = director.ConstructUnit(new ZergBuilder());
}
public static void Test()
{
var director = new Director();
director.Construct(new ConcreteBuilder1());
director.Construct(new ConcreteBuilder2());
}
// Use this for initialization
void Start()
{
as_bass = GetComponent<AudioSource>();
dir = GameObject.Find("DirectorObj");
director = dir.GetComponent<Director>();
button = GetComponentInChildren<ButtonAlphaControl>();
}
// Use this for initialization
void Start()
{
dir = GameObject.FindGameObjectWithTag ("Director").GetComponent<Director>();
MainPlayerScript mpRef = GameObject.FindGameObjectWithTag ("Player").GetComponent<MainPlayerScript>();
mpRef.CanChange (MainPlayerScript.State.Plasma, false);
mpRef.CanChange (MainPlayerScript.State.Gas, false);
}
public static void EX1()
{
Director director = new Director(new ConcreteBuilder());
director.BuildObject();
Product concrete = director.GetObject();
Console.WriteLine(concrete.Nome + " - " + concrete.Description);
}
/// <summary>
/// 指定されたファイルを読み込みブックを作成する。
/// </summary>
/// <param name="filePath">ファイルパス</param>
/// <param name="director">ディレクタ</param>
private Book(string filePath, Director director)
{
this.filePath = filePath;
this.director = director;
Author author = director.AssignAuthor(this);
author.Write(this);
this.author = author;
}
public void DirectorTest()
{
var log = A.Fake<ILog>();
var director = new Director(log);
Assert.IsNotNull(director);
}
public Director Update(Director director)
{
var dir = _context.Directors.FirstOrDefault(cp => cp.Id == director.Id);
if (dir == null) throw new ArgumentException();
_context.Entry(director).State = System.Data.Entity.EntityState.Modified;
_context.SaveChanges();
return dir;
}
public void GivenAdditionalRoleSpecification(string role)
{
if(TheDirector == null)
TheDirector = new SaladDirector();
Primary = role;
SetActor(role, new Actor(role,TheDirector));
}
public void Awake() {
Instance = this;
isGameStartNormally = true;
thisTransform = transform;
container = new GameObject("Container").transform;
container.position = Vector3.zero;
container.parent = thisTransform;
container.transform.localScale += new Vector3(0.0f, 0.0f, 0.001f);
SetScreen(startScreen);
}
public void Create(string name, int age)
{
var director = new Director
{
Name = name,
Age = age
};
this.data.Add(director);
this.data.SaveChanges();
}
public ActionResult Create(Director director)
{
if (ModelState.IsValid)
{
db.Directors.Add(director);
db.SaveChanges();
return RedirectToAction("Index");
}
return View(director);
}
// Use this for initialization
void Start()
{
GameObject temp = GameObject.Find("player_prefab");
thePlayer = temp.GetComponent<player_class>();
combos = temp.GetComponent<combo_master>();
GameObject temp2 = GameObject.Find("GUI - Bar");
tolerance = temp2.GetComponent<GUIScript>();
GameObject temp3 = GameObject.Find("Director");
theDirector = temp3.GetComponent<Director>();
}
public void ConstructTest()
{
var log = A.Fake<ILog>();
var dataBuilder = A.Fake<IDataBuilder>();
var director = new Director(log);
director.Construct(new List<IDataBuilder> { dataBuilder });
A.CallTo(() => dataBuilder.CreateStructure()).MustHaveHappened();
A.CallTo(() => dataBuilder.ValidateStructure()).MustHaveHappened();
A.CallTo(() => dataBuilder.WriteStructure()).MustHaveHappened();
}
static void Main(string[] args)
{
//house building
Builder.Builder b = new ConcreteBuilder();
Foreman f = new Foreman(b);
f.Construct();
House h = b.GetResult();
//bottle building
BottleBuilder.BottleBuilder bb = new PepsiBottleBuilder();
Director d = new Director(bb);
d.Construct();
Bottle bottle = bb.GetBottle();
}
static void Main()
{
game = new Director(800,600);
game.Script.Invoke(() => {
game.PushScene(new ExampleScene(), Effects.SceneSwitchEffects.Fade,2.0f);
}).Wait(4.0f).Invoke(()=>{
game.PushScene(new ExampleScene(), Effects.SceneSwitchEffects.Fade, 2.0f);
}).Wait(4.0f).Invoke(() =>
{
game.PushScene(new ExampleScene(), Effects.SceneSwitchEffects.SlideRight, 1f);
});
game.Run();
}
/// <summary>
/// Called when Mac app is finished launching.
/// </summary>
/// <param name='notification'>
/// Notification.
/// </param>
public override void FinishedLaunching(NSObject notification)
{
game = new Director(800,600);
game.Script.Invoke(() => {
game.PushScene(new ExampleScene(), Effects.SceneSwitchEffects.Fade, 2.0f);
}).Wait(4.0f).Invoke(()=>{
game.PushScene(new ExampleScene(), Effects.SceneSwitchEffects.Fade, 2.0f);
}).Wait(4.0f).Invoke(() =>
{
game.PushScene(new ExampleScene(), Effects.SceneSwitchEffects.SlideRight, 1f);
});
game.Run();
}
public DirectorForm()
{
InitializeComponent();
nombreTextBox.Select();
errorProvider.Icon = Resources.dialogError16x16;
errorProvider.SetIconPadding(nombreTextBox, -20);
errorProvider.SetIconPadding(apellidoTextBox, -20);
director = new Director();
formValidator = new FormValidator(this);
nombreNotEmptyRule = new NotEmptyValidationRule(nombreLabel.Text);
}
public Client()
{
Director director = new Director();
Builder b1 = new ConcreteBuilder1();
Builder b2 = new ConcreteBuilder2();
director.Construct(b1);
Product p1 = b1.GetResult();
p1.Show();
director.Construct(b2);
Product p2 = b2.GetResult();
p2.Show();
}
void UnitTest()
{
// 建立
Director theDirectoir = new Director();
Product theProduct = null;
// 使用BuilderA建立
theDirectoir.Construct( new ConcreteBuilderA());
theProduct = theDirectoir.GetResult();
theProduct.ShowProduct();
// 使用BuilderB建立
theDirectoir.Construct( new ConcreteBuilderB());
theProduct = theDirectoir.GetResult();
theProduct.ShowProduct();
}
void Start () {
inMainMenu = true;
Time.timeScale=0;
coseMenu = GameObject.Find ("CoseMenu");
cosePausa = GameObject.Find ("CosePausa");
camera = GameObject.Find ("Main Camera").GetComponent<Camera>();
blackForeground = GameObject.Find ("black").GetComponent<SpriteRenderer>();
text = GameObject.Find ("score").GetComponent<Text> ();
sequence = GameObject.Find("sequence").GetComponent<Text>();
blackForeground.color = new Color (blackForeground.color.r, blackForeground.color.g, blackForeground.color.b, 0);
cameraOriginal = camera.transform.localPosition;
camera.transform.Translate(new Vector2(0,90));
coseMenu.SetActive (true);
cosePausa.SetActive (false);
dir = GameObject.Find("DirectorObj").GetComponent<Director>();
}
public static void Main()
{
// Create director and builders
Director director = new Director();
Builder b1 = new ConcreteBuilder1();
Builder b2 = new ConcreteBuilder2();
// Construct two products
director.Construct(b1);
Product p1 = b1.GetResult();
p1.Show();
director.Construct(b2);
Product p2 = b2.GetResult();
p2.Show();
// Wait for user
Console.Read();
}
void Awake()
{
if (instance == null)
{
instance = this;
Managers = Instantiate(ManagersPrefab);
Managers.SetActive(true);
Managers.name = "Managers";
Managers.transform.SetParent(this.transform);
Managers.transform.localPosition = Vector3.zero;
Managers.transform.localScale = Vector3.one;
}
else
{
Destroy(gameObject);
}
}
public void InsertDirectorTest()
{
using (var db = new CSBCDbContext())
{
var repHouse = new HouseholdRepository(db);
var house = repHouse.Insert(new Household {CompanyID=2, Name="Frost"});
var repPeople = new PersonRepository(db);
var person = repPeople.Insert(new Person { FirstName = "Jack", LastName = "Frost", HouseID = house.HouseID });
var rep = new DirectorRepository(db);
var director = new Director{ PeopleID = person.PeopleID, CompanyID = 2, Title = "President" };
var records = rep.Insert(director);
Assert.IsTrue(records.PeopleID != 0);
Assert.IsTrue(records.Title != String.Empty);
//rep.Delete
}
}
public static void Main( )
{
// Create one director and two builders
Director director = new Director( );
IBuilder b1 = new Builder1( );
IBuilder b2 = new Builder2( );
// Construct two products
director.Construct(b1);
Product p1 = b1.GetResult( );
p1.Display( );
director.Construct(b2);
Product p2 = b2.GetResult( );
p2.Display( );
}
void Awake()
{
if (instance == null)
{
instance = this;
}
else
{
Debug.LogError("There were two Directors. Deleting one");
Destroy(this.gameObject);
}
try{
gameTimeText = GameObject.Find("GUI Mission Time").GetComponent<Text>();
playerKillsText = GameObject.Find("GUI Kills").GetComponent<Text>();
}catch{}
}
void Start()
{
//m_fullAnimTiming = 0.2f;
m_animTiming = 0f;
ResetAnimation();
m_director = FindObjectOfType<Director>();
CompileStatsFromAncestors();
if(_maxEnergy==0)
_maxEnergy = 100f;
if(_fillEnergy==0)
_fillEnergy = 0.1f;//0.001f;
_currentEnergy = _maxEnergy;
}
private static void Main()
{
var larry = new Director();
var sam = new VicePresident();
var tammy = new President();
larry.SetSuccessor(sam);
sam.SetSuccessor(tammy);
var purchase = new Purchase(1231, 350.0, "Assets");
larry.ProcessRequest(purchase);
purchase = new Purchase(321, 12313.123, "Project X");
larry.ProcessRequest(purchase);
purchase = new Purchase(123123, 123123123.123, "Project Y");
larry.ProcessRequest(purchase);
}
void Start ()
{
m_director = FindObjectOfType<Director>();
if ( m_director == null )
Debug.LogWarning("Enemy Manger is not finding the director");
if (_enemyList.Count == 0)
{
Debug.LogWarning ("No Enemies in EnemySpawner List, please populate and maybe create a prefab");
}
else
{
m_currentEnemySpawnQueue = new Queue<GameObject>();
for ( int i = 0; i < _enemyList.Count; i++ )
{
// Fill Enemy Queue for the first time
m_currentEnemySpawnQueue.Enqueue( _enemyList[i] );
}
if ( _enemyList.Count == 0 )
Debug.LogWarning("Enemey Manger Enemy List is empty, please populate");
}
_combatController = FindObjectOfType<CombatController>();
if (_combatController == null)
Debug.LogWarning ("Enemy Manager couldn't find a combatcontroller!");
m_currentSpawnInterval = 0;
if ( _enemyPosition == null )
_enemyPosition = GameObject.Find("EnemyPosition").transform;
else
Debug.LogWarning ("No Enemey Position found, please add Gameobject to scene as transform reference on Enemy Manger");
SpawnNewEnemy ();
}
public EmailSendButtonClickListener(Director director)
{
this.director = director;
}
public GameLoop(Director director)
{
stepLength = 3;
this.director = director;
}
// Use this for initialization
void Start()
{
user = Director.getInstance().currentSceneController as IUserAction;
}
public CossButtonClickListener(Director director, MainPage mainPage)
{
this.director = director;
this.mainPage = mainPage;
}
protected void Start()
{
sceneCtrl = (FirstSceneController)Director.GetDirector().CurrentSceneCtrl;
sceneCtrl.actionManager = this;
fly.Add(CCFlyAction.GetSSAction());
}
static void Main(string[] args)
{
{
//简单工厂模式：定义一个工厂类，它可以根据参数的不同返回不同类的实例，被创建的实例通常都具有共同的父类。
//Product product = Factory.GetProduct("电脑");
//product.Production();
//product.WhatProduction();
}
{
//工厂方法模式：定义一个用于创建对象的接口，但是让子类决定将哪一个类实例化，工厂方法模式让一个类的实例化延迟到其子类。
//IFactory factory = new AppleFactory();
//IFruits fruits = factory.WhatProduct("");
//fruits.CreateFruits();
LoggerFactory factory = new SelectFactory();
factory.WriteLog();//记录查询
//优点：相比于简单工厂模式，工厂模式的拓展性更加的好。
//工厂方法用来创建客户端所需要的东西，但是隐藏了具体实例化的细节。
//缺点：每次新增加一个产品需要些一个具体的产品，和产品的工厂类。。。。
}
{
//抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类
//LogicFactory logicFactory = new LogicFactory();
//ISkinFactory factory = logicFactory.CheckFacotry(SkinType.Trend);
//IButton button = factory.CreateButton();
//ICheckBox checkBox = factory.CreateCheckBox();
//button.Display();
//checkBox.Display();
}
{
//建造者模式:讲一个辅助对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
{
//一般情况
ActorController controller = new ActorController(); //实例化指挥者
ActorBuilder builder = new AngleBuilder(); //创建天使
Actor actor = controller.Construct(builder); //返回角色具体的信息
Console.WriteLine(actor.Type);
Console.WriteLine(actor.Name);
}
{
//ActorController controller = new ActorController();//实例化指挥者
//ActorBuilder builder = new DevilBuilder();//创建恶魔
//Actor actor = controller.Construct(builder);//返回角色具体的信息
//Console.WriteLine(actor.Type);
//Console.WriteLine(actor.Name);
}
{
//合并指挥者和抽象建造者
//AngleBuilder angle = new AngleBuilder();
//Actor actor = ActorBuilder.CreateActor(angle);
//Console.WriteLine(actor.Type);
//Console.WriteLine(actor.Name);
}
{
//原型模式:使用原型实例指定待创建对象的类型，并且通过复制这个原型来创建新的对象
{
//通用实现
//ConcretePrototype prototype = new ConcretePrototype();
//prototype.Attr = "机器人壹号";
//ConcretePrototype copy = (ConcretePrototype)prototype.Clone();
//Console.WriteLine("克隆"+copy.Attr);
//Console.WriteLine(prototype==copy);//false--虽然复制了对象但是内存中的对象副本不是同一个所以他们是不相等的
//Console.WriteLine(prototype.Attr==copy.Attr);//false
}
{
//c#中的 MemberwiseClone和 ICloneable
//MemberwiseClone实现浅克隆
//ConcretePrototypeA prototype = new ConcretePrototypeA();
//var copy = (ConcretePrototypeA)prototype.Clone();
//Console.WriteLine(copy==prototype);
//Console.WriteLine(copy.Member==prototype.Member);//ture --复制后的两个对象相等说明是浅克隆
}
{
//ICloneable实现深克隆
//ConcretePrototypeB prototype = new ConcretePrototypeB();
//var copy = (ConcretePrototypeB)prototype.Clone();
//Console.WriteLine(copy == prototype);//false
//Console.WriteLine(copy.Member == prototype.Member);//false
}
}
{
////单例模式：确保一个类只有一个实例，并提供一个全局访问点来访问这个唯一的实例。
//{
// //普通
// Singleton s1 = Singleton.GetInstance();
// Singleton s2 = Singleton.GetInstance();
// Console.WriteLine(s1==s2);//true
//}
//{
// //饿汉式:在类被加载时就实例化自己，好处在于它是能够保证线程安全的，由于单例对象是在一开始就创建，所以调用速度和反应时间都是比懒汉式快的，但是在系统资源的利用方面饿汉式是不如懒汉式的，这很好理解，因为饿汉式是会一直占用系统资源的，但是懒汉式是需要的时候才去加载。
// EagerSingleton s1 = EagerSingleton.GetIntance() ;
// EagerSingleton s2 = EagerSingleton.GetIntance();
// Console.WriteLine(s1==s2);
//}
//{
// //懒汉式:懒汉式在第一次实例化的时候创建，但是不会一直占用系统资源，实现了延时加载，但是随之而来的问题就是多个线程同时访问的问题，特别是当单例类作为资源控制器，在实例化时必然会涉及到资源初始化，而资源初始化很有可能耗费打量的时间，这意味着出现多线程同时首次引用此类的概率会比较大，通过双重检查锁定等机制进行控制，这 将导致系统性能收到一定的影响。
// LazySingleton s1 = LazySingleton.GetInstance();
// LazySingleton s2 = LazySingleton.GetInstance();
// Console.WriteLine(s1 == s2);
//}
}
}
{
////适配器模式：将一个类的接口换成客户希望的另一个接口，适配器模式让那些接口不兼容的类可以一起工作。
//{
// //类适配器
// ClassAdapter adapter = new ClassAdapter();
// adapter.Request();
//}
//{
// //对象适配器
// Adaptee adaptee = new Adaptee();
// ObjectAdapter adapter = new ObjectAdapter(adaptee);
// adapter.Request();
//}
//{
// //缺省适配器模式
// ConcreteService service = new ConcreteService();
// service.Face1();
//}
//{
// //双向适配器模式
// Adaptee adaptee = new Adaptee();
// Twoway twoway = new Twoway(adaptee);
// twoway.Request();//互相只能使用对方的方法，即：适配者类使用的是request方法，目标具体类使用适配者类的方法，否者会报错，这个？？？？？？？？？？？
// Target target = new Target();
// Twoway twoway2 = new Twoway(target);
// twoway2.SpecificRequest();
//}
}
{
//桥接模式：将抽象部分与它的实现部分解耦，使得两者能够独立变化
RefinedAbstraction refined = new RefinedAbstraction();
//ConcreteImplementor concrete = new ConcreteImplementor();
//refined.SetImp1(concrete);
//refined.OperationImp();
}
{
//装饰模式:动态地给一个对象增加一些额外的职责。就扩展功能而言，装饰模式提供了一种比使用子类更灵活的替代方案
//{
// //寻常调用
// ConcreteComponent component = new ConcreteComponent();
// ConcreteDecorator decorator = new ConcreteDecorator(component);
// decorator.Operation();
// decorator.Add();
//}
//{
// //透明模式
// Component component = new ConcreteComponent();
// Component decorator = new ConcreteDecorator(component);
// decorator.Operation();
// //decorator.Add();无法单独调用该方法，但是可以放在Operation方法中一起执行
//}
//{
// //半透明模式
// Component component = new ConcreteComponent();//使用抽象构件类型定义
// component.Operation();
// ConcreteDecorator decorator = new ConcreteDecorator(component);//使用具体装饰定义
// decorator.Add();//单独使用新增方法。
//}
}
{
//外观模式：为子系统中的一组接口提供一个统一的入口。外观模式定义一个高层接口，这个接口是的这一子系统更容易使用。
//Facade facade = new Facade();
//facade.Meathod();
}
{
//享元模式：运用共享技术有效的支持大量细粒度对象的复用。
{
//IgoChessmanFactory factory = IgoChessmanFactory.GetIntance();
//var white = factory.GetIgoChessman("w");
//white.GetColor();
//white.Display(new Coordinates(1, 2));
//var black = factory.GetIgoChessman("b");
//black.GetColor();
//black.Display(new Coordinates(2, 1));
}
{
//复合享元对象，使多个内部状态不同的对象设置为相同的外部状态（结合组合模式使用）
//IgoChessmanFactory factory = IgoChessmanFactory.GetIntance();
//var w1= factory.GetIgoChessman("w");
//var w2= factory.GetIgoChessman("w");
//var w3= factory.GetIgoChessman("w");
//var w4= factory.GetIgoChessman("w");
//var b1= factory.GetIgoChessman("b");
//var b2= factory.GetIgoChessman("b");
//var b3= factory.GetIgoChessman("b");
//var b4= factory.GetIgoChessman("b");
//CompositeConcreteFlyWeight flyWeight = new CompositeConcreteFlyWeight();
//flyWeight.Add(w1, new Coordinates(1, 1));
//flyWeight.Add(w2, new Coordinates(1, 2));
//flyWeight.Add(w3, new Coordinates(1, 3));
//flyWeight.Add(w4, new Coordinates(1, 4));
//flyWeight.Add(b1, new Coordinates(2, 1));
//flyWeight.Add(b2, new Coordinates(2, 2));
//flyWeight.Add(b3, new Coordinates(2, 3));
//flyWeight.Add(b4, new Coordinates(2, 4));
//flyWeight.Display();
}
}
{
//代理模式：给某一个对象提供一个代理或占位符，并由代理对象来控制对原对象的访问
//远程代理
//虚拟代理
//缓冲代理
//保护代理
//智能引用代理
{
//保护代理+智能代理
//ProxySearcher searcher = new ProxySearcher();
//searcher.DoSearch("Zero", "敏敏");
}
}
{
//职责链模式：避免将一个请求的发送者与接受者耦合在一起，让多个对象都有机会处理请求。将接受的对象连接成一条链，并且沿着这条链传递请求，知道一个对象能够处理它为止。
Approver approver, approver1, approver2;
approver = new Director("张主任");
approver1 = new VicePresident("张副总");
approver2 = new President("张总");
//创建职责链
approver.SetSuccesser(approver1);//下级传递给上一级
approver1.SetSuccesser(approver2);
PurchaseRequest request = new PurchaseRequest(5_5_0_0_0, 10001, "买电脑");
approver.ProcessRequest(request);
}
{
//迭代器模式：提供一种方法访问一个聚合元素中的各个元素，并且不暴露对象的内部表示
//List<object> list = new List<object>();
//list.Add("张大力");
//list.Add("罗小敏");
//AbstractObjectList productList = new ProductList(list);//创建聚合对象
//AbstractIterator iterator = productList.CreateIterator();//创建迭代对象
//while (!iterator.IsLast())//正向遍历
//{
// Console.WriteLine(iterator.GetNextItem());
// iterator.Next();
//}
//while (!iterator.IsFirst())//反向遍历
//{
// Console.WriteLine(iterator.GetPreviousItem());
// iterator.Previous();
//}
}
{
//中介者模式：定义一个对象封装一系列对象的交互，中介者模式使对象之间不需要显示的相互引用，从而使其耦合松散，而且你可以独立的改变他们之间的交互。
//定义中介者对象
//ConcreteMediator concrete = new ConcreteMediator();
//定义同事对象
//Button button = new Button();
//ListView listView = new ListView();
//TextBox textBox = new TextBox();
////设置中介者
//button.SetMediator(concrete);
//listView.SetMediator(concrete);
//textBox.SetMediator(concrete);
//concrete.TextBox = textBox;
//concrete.ListView = listView;
//concrete.Button = button;
//button.Charged();
//textBox.Charged();
//listView.Charged();
}
{
//备忘录模式：在不破坏封装的情况下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样就可以将对象恢复到原先保存的状态
//Execute.Invoke();
//Execute.Invokes();
}
{
//观察者模式：定义对象之间的一种一对多的依赖关系，使得每一个对象的状态发生改变时，其相关依赖对象得到通知并且自动更新。
//AllyControllerCenter center = new ConcreteAllyControllerCenter("王者荣耀群");
//IObserver observer, observer1, observer2, observer3, observer4;
//observer = new Player("鲁班七号");
//center.AddPlayer(observer);
//observer1 = new Player("蔡文姬");
//center.AddPlayer(observer1);
//observer2 = new Player("甄姬");
//center.AddPlayer(observer2);
//observer3 = new Player("李白");
//center.AddPlayer(observer3);
//observer4 = new Player("凯");
//center.AddPlayer(observer4);
////鲁班被毒打
//observer.BeAttacked(center);
}
{
//命令模式：将一个请求封装为一个对象，从而让你可以用不同的请求对客户进行参数化，对请求排队或者记录请求日志，以及支持撤销的功能。
//Command command, command1;
//command = new ExitCommand();
//command1 = new HelpCommand();
//FunctionButton button = new FunctionButton();
//button.Command = command;
////button.Click();
//CommandQueue queue = new CommandQueue();//命令队列，CommandQueue的Excute方法虽然可以使用但是客户端使用不够好的，必须要让请求对象FunctionButton来发送请求。
//queue.AddCommand(command);
//queue.AddCommand(command1);
////queue.Excute();
//button.Clicks(queue);
}
{
//解释器模式：给定一个语言，定义他的文法的一种表示，并定义一个解释器，这个解释器表示来解释语言中的句子。
//string str = "down run 10 and left move 20";
//InstruetionHandler handler = new InstruetionHandler();
// handler.Handle(str);
//var result = handler.Output();
//Console.WriteLine(result);
}
{
//状态模式:允许一个对象在其内部状态发生改变的时改变它的行为。对象看起来似乎没有修改它的类
{
//普通情况
//Acount acount = new Acount("Zero", 0);
//acount.Deposit(1000);
//acount.Withdraw(5000);
//acount.ComputeInterest();
}
{
//共享状态
//StatePattern.共享状态.Switch s = new StatePattern.共享状态.Switch("开关1");
//StatePattern.共享状态.Switch s2 = new StatePattern.共享状态.Switch("开关2");
//s.Off();
}
}
{
//策略模式：定义一系列算法，将每一个算法封装起来，并让它们可以相互替换。策略模式让算法可以独立于使用它们的客户端
//Strategy strategy = new Strategy();
//strategy.SetDiscount(new Student());
//Console.WriteLine("原价{0}",100);
//strategy.Price = 100;
//Console.WriteLine("折后{0}",strategy.Price);
//Console.WriteLine("============================");
//strategy.SetDiscount(new Children());
//strategy.Price = 100;
//Console.WriteLine("折后{0}", strategy.Price);
}
{
//模板方法模式:定义一个操作中算法的框架，而将一些步骤延迟到子类中，模板方法模式使得子类不改变一个算法的结构就可以重定义算法的某些特定的方法
{
//CurrnetAccount account = new CurrnetAccount();
//account.TemplateMethod("111");
//account.TemplateMethod("Zero");
}
}
{
//访问者模式：表示一个作用于某个对象接口中的各个元素的操作。访问者模式让你可以在不改变任何元素的类的前提下定义作用于这些元素的新操作
//EmployeeList list = new EmployeeList();
//Employee e1, e2, e3;
//e1 = new FullTimeEmployee("Zero",3000,50);
//e2 = new FullTimeEmployee("One",5000,40);
//e3 = new PartTimeEmployee("Two",2500,35);
//list.Add(e1);
//list.Add(e2);
//list.Add(e3);
//list.Accept(new HR());
//Console.WriteLine("=========================");
//list.Accept(new FA());
}
Console.ReadKey();
}
static void Main(string[] args)
{
string selection = "";
Director director = null;
UIHelper.PrintUsage();
Console.WriteLine();
do
{
Console.Write("\n >");
string input = Console.ReadLine();
selection = input.Contains(':') ? input.Remove(input.IndexOf(':')).ToUpper() : input.ToUpper();
switch (selection)
{
case "HELP":
UIHelper.PrintUsage();
break;
case "MODE":
if (input.Substring(input.IndexOf(':') + 1).ToUpper().Equals("JSON"))
{
director = new Director("JSON");
}
else if ((input.Substring(input.IndexOf(':') + 1).ToUpper().Equals("XML")))
{
director = new Director("XML");
}
else
{
Console.WriteLine("\nInvalid input. For Usage, type 'Help'\n");
}
break;
case "BRANCH":
if (director is null)
{
Console.WriteLine("Error. Mode has not been set. For usage, type 'Help'");
break;
}
if (String.IsNullOrEmpty(input.Substring(input.IndexOf(':') + 1)) || !input.Contains(':'))
{
Console.WriteLine("\nInvalid input. For Usage, type 'Help'\n");
break;
}
director._name = input.Substring(input.IndexOf(':') + 1);
director.BuildBranch();
break;
case "LEAF":
if (director is null)
{
Console.WriteLine("Error. Mode has not been set. For usage, type 'Help'");
break;
}
if (input.Count(x => x == ':') != 2)
{
Console.WriteLine("Invalid input. For Usage, type 'Help'");
break;
}
int firstDelim = input.IndexOf(':') + 1;
int secondDelim = input.LastIndexOf(':');
string name = input.Substring(firstDelim, secondDelim - firstDelim);
string content = input.Substring(secondDelim + 1);
if (String.IsNullOrWhiteSpace(name) || String.IsNullOrWhiteSpace(content))
{
Console.WriteLine("Invalid input. For Usage, type 'Help'");
break;
}
director._name = name;
director._content = content;
director.BuildLeaf();
break;
case "CLOSE":
if (director is null)
{
Console.WriteLine("Error. Mode has not been set. For usage, type 'Help'");
break;
}
director.CloseBranch();
break;
case "PRINT":
if (director is null)
{
Console.WriteLine("Error. Mode has not been set. For usage, type 'Help'");
break;
}
director.Print();
break;
case "EXIT":
break;
default:
Console.WriteLine("Invalid input. For Usage, type 'Help'");
break;
}
} while (!selection.Equals("EXIT"));
}
void Start()
{
setNewPath();
dir = Director.getInstance();
}
public Behavior(Director gDirector)
{
director = gDirector;
HasActioned = false;
HasChosen = false;
}
public void buildModule(Director directorInput)
{
buildModule(directorInput, new Vector3(0, 0, 0));
baseUnit.buildUnit(this, 0, modulePosition, false);
}
static void Main(string[] args)
{
var serviceUri = new Uri("http://localhost:8302/odata");
var dataServiceContext = new ExtendedDataServiceContext(serviceUri);
dataServiceContext.ResolveType = name => {
switch (name)
{
case "ServiceNS.Models.Genre":
return(typeof(Genre));
case "ServiceNS.Models.Address":
return(typeof(Address));
case "ServiceNS.Models.NextOfKin":
return(typeof(NextOfKin));
case "ServiceNS.Models.Director":
return(typeof(Director));
default:
return(null);
}
};
dataServiceContext.ResolveName = type =>
{
// Lazy approach
return(string.Format("{0}.{1}", "ServiceNS.Models", type.Name));
};
// Query for entity by key
var query = dataServiceContext.CreateQuery <Director>("Directors(1)");
var queryResult = query.ExecuteAsync().Result;
var director = queryResult.FirstOrDefault();
var director2 = new Director {
Id = 2, Name = "Director 2 "
};
director2.DynamicProperties = new Dictionary <string, object>
{
{ "Title", "Prof." },
{ "YearOfBirth", 1971 },
{ "Salary", 800000m },
{ "BigInt", 7454777478706L },
{ "EulerConst", 0.5772156649d },
{ "NickNames", new List <string> {
"N3"
} },
{ "FavoriteGenre", Genre.Thriller },
{ "Genres", new List <Genre> {
Genre.SciFi
} },
{ "WorkAddress", new Address {
AddressLine = "AL5", City = "C5"
} },
{
"Addresses",
new List <Address>
{
new Address {
AddressLine = "AL6", City = "C6"
},
new Address {
AddressLine = "AL7", City = "C7"
}
}
},
{
"NextOfKin",
new NextOfKin
{
Name = "Nok 2",
HomeAddress = new Address
{
AddressLine = "AL7",
City = "C7",
DynamicProperties = new Dictionary <string, object> {
{ "PostalCode", "PC7" }
}
}
}
}
};
dataServiceContext.AddObject("Directors", director2);
dataServiceContext.SaveChangesAsync().Wait();
}
private void GameWindowDesktop_KeyPress(object sender, KeyPressEventArgs e)
{
switch (e.KeyChar)
{
case 'a':
Player.Autoplay = !Player.Autoplay;
break;
case 'r':
Director.ChangeMode(Director.CurrentOsuMode);
break;
case 'd':
TextureManager.PurgeUnusedTexture();
break;
case 's':
TextureManager.ReloadAll();
break;
case 'z':
TextureManager.DisposeAll();
break;
case 'o':
Director.ChangeMode(OsuMode.Options);
break;
case 'v':
Director.ChangeMode(OsuMode.VideoPreview, new FadeTransition(1000, 1500));
return;
case 'e':
DifficultyScoreInfo bmi = BeatmapDatabase.GetDifficultyInfo(Player.Beatmap, Difficulty.Normal);
if (bmi == null)
{
break;
}
if (bmi.HighScore == null)
{
GameBase.Notify("Unlocked expert");
bmi.HighScore = new Score();
bmi.HighScore.comboBonusScore = 1000000;
}
break;
case 'k':
Director.ChangeMode(OsuMode.PositioningTest);
break;
case 'h':
if (ClientSize.Width == 960)
{
ClientSize = new Size(480, 320);
}
else
{
ClientSize = new Size(960, 640);
}
break;
case 'x':
if (ClientSize.Width == 1218)
{
ClientSize = new Size(2436, 1125);
}
else
{
ClientSize = new Size(1218, 562);
}
break;
case 'i':
ClientSize = new Size(1024, 768);
break;
case '5':
ClientSize = new Size(1136, 640);
break;
case '1':
ClientSize = new Size(896, 414);
break;
case '2':
ClientSize = new Size(896 * 2, 414 * 2);
break;
case '3':
ClientSize = new Size(2560, 1182);
break;
case 'p':
{
if (Director.CurrentMode is Player)
{
Player p = Director.CurrentMode as Player;
if (!p.IsPaused)
{
p.Pause();
}
}
else
{
Director.ChangeMode(OsuMode.SongSelect);
}
}
break;
case 'j':
{
if (Director.CurrentMode is Player p)
{
Results.RankableScore = p.CurrentScore;
Director.ChangeMode(OsuMode.Results, new ResultTransition());
}
}
break;
}
}
[SuppressMessage("ReSharper", "SuggestBaseTypeForParameter")] // we actually want only DefensePlatforms to be able to shoot. Everything else is too generic though.
public Shoot(DefenseBase platform, ref Director director) : base(platform, ref director)
{
AmmoCount = 10;
mPlatform = platform;
}
public FBNoButtonClickListener(Director director)
{
this.director = director;
}
public static int Handle(Director director, CreateDirector createDirector)
{
return(createDirector(director));
}
protected new void Start()
{
sceneController = (FirstController)Director.getInstance().sceneController;
sceneController.actionManager = this;
}
void Start()
{
firstSceneControl = (FirstSceneControl)Director.getInstance().currentSceneControl;
}
public ActionResult Director_Delete([DataSourceRequest] DataSourceRequest request, Director model)
{
_directorService.Delete(model.Id);
return(Json(new[] { model }.ToDataSourceResult(request, ModelState)));
}
void Awake()
{
dir = Director.getInstance();
dir.setGenGameObject(this);
load();//加载游戏场景
}
void OnEnable()
{
if (Director == null || Director.playableAsset == null)
{
Debug.LogError(
$"You must call {nameof(SetupFromRecordingInfo)} on {nameof(RecordedSessionDirector)} before enabling it");
enabled = false;
return;
}
IsStarting = true;
m_Paused = false;
Director.RebuildGraph(); // Ensure new playables are created
SetTime(0d);
Director.Play();
Director.played += OnResumed;
Director.paused += OnPaused;
Director.stopped += OnStopped;
IsPlaying = true;
IsStarting = false;
Played?.Invoke();
// Notifications do not fire from manual timeline updates.
// https://answers.unity.com/questions/1665172/markers-and-signal-emitters-not-working-when-timel.html
// We must sort notifications by time and then directly send them to receivers for manual evaluation.
var playableGraph = Director.playableGraph;
var outputCount = playableGraph.GetOutputCount();
m_TimelineNotifications.Clear();
m_NotificationReceivers.Clear();
m_NotificationsSent = 0;
for (var i = 0; i < outputCount; i++)
{
var output = playableGraph.GetOutput(i);
var playable = output.GetSourcePlayable().GetInput(i);
var track = output.GetReferenceObject() as TrackAsset;
if (track == null || !(track is MarkerTrack))
{
continue;
}
var targetObject = Director.GetGenericBinding(track);
if (targetObject == null)
{
continue;
}
var targetGameObject = targetObject as GameObject;
var targetComponent = targetObject as Component;
if (targetGameObject == null && targetComponent == null)
{
continue;
}
var notificationReceivers = new List <INotificationReceiver>();
if (targetGameObject != null)
{
targetGameObject.GetComponents(notificationReceivers);
}
else
{
targetComponent.GetComponents(notificationReceivers);
}
m_NotificationReceivers[playable] = notificationReceivers;
foreach (var marker in track.GetMarkers())
{
if (!(marker is INotification notification))
{
continue;
}
m_TimelineNotifications.Add(new NotificationData
{
Notification = notification,
Time = marker.time,
Origin = playable
});
}
}
m_TimelineNotifications.Sort((first, second) => first.Time.CompareTo(second.Time));
}
protected new void Start()
{
sceneController = (FirstSceneControl)Director.getInstance().currentSceneControl;
sceneController.actionManager = this;
Fly.Add(Emit.GetSSAction());
}
/// <summary>
/// Indicates that one or more policies were selected by the client asked to select policies.
/// </summary>
/// <param name="policies">The selected policies.</param>
public async Task PoliciesSelected(IEnumerable <PolicyType> policies)
{
var myPolicies = policies.ToList();
switch (GameData.MachineState)
{
case StateMachineState.AwaitingEnactedPolicy:
// TODO Validate policy was actually drawn, delivered by correct player
if (myPolicies.Count != Constants.ChancellorPolicySelectionCount)
{
throw new GameStateException("Too many policies selected for the current game state.");
}
var policy = myPolicies.First();
if (policy == PolicyType.None)
{
if (!AllowVetoes)
{
throw new GameStateException("Currently not eligible to veto policies.");
}
await Director.Broadcast("A veto has been requested.");
GameData.MachineState = StateMachineState.AwaitingVetoResponse;
await Director.ApproveVeto(GameData.President);
return;
}
foreach (var p in myPolicies)
{
GameData.DrawnPolicies.Remove(p);
}
PolicyDeck.Discard(GameData.DrawnPolicies);
GameData.DrawnPolicies = null;
if (policy == PolicyType.Fascist)
{
await Director.Broadcast("A fascist policy has been enacted!");
GameData.EnactedFascistPolicyCount++;
await DisseminateGameData();
if (InvokeCurrentPresidentialPower())
{
return;
}
}
else if (policy == PolicyType.Liberal)
{
await Director.Broadcast("A liberal policy has been enacted!");
GameData.EnactedLiberalPolicyCount++;
}
await PrepareNextElection();
break;
case StateMachineState.AwaitingPresidentialPolicies:
// TODO Validate policy was actually drawn, delivered by correct player
// TODO Test me.
if (myPolicies.Count != Constants.PresidentialPolicyPassCount)
{
throw new GameStateException("Too many/few policies selected for the current game state.");
}
foreach (var p in myPolicies)
{
GameData.DrawnPolicies.Remove(p);
}
PolicyDeck.Discard(GameData.DrawnPolicies);
GameData.DrawnPolicies = policies.ToList();
await Director.Broadcast("The president has offered policies to the chancellor.");
GameData.MachineState = StateMachineState.AwaitingEnactedPolicy;
await Director.GetEnactedPolicy(GameData.Chancellor, policies, AllowVetoes);
break;
default:
throw new GameStateException($"{nameof(PoliciesSelected)} called for invalid state {GameData.MachineState}.");
}
}
private void Awake()
{
director = GameObject.FindObjectOfType <Director>();
}
private void DirectorToDto(Director director, DirectorDTO dto)
{
dto.Id = director.Id;
dto.FirstName = director.FirstName;
dto.LastName = director.LastName;
}
// Use this for initialization
void Start()
{
this.transform.localScale = new Vector3(0, 0, 0);
d = GameObject.Find("ScriptTester").GetComponent <Director>();
}
private void DtoToDirector(DirectorDTO dto, Director director)
{
director.Id = dto.Id;
director.FirstName = dto.FirstName;
director.LastName = dto.LastName;
}
public void Evaluate()
{
IsEvaluating = true;
Director.Evaluate();
IsEvaluating = false;
}
void Update()
{
GameObject hero = ((FirstControl)Director.getInstance().sceneCtrl).gameModel.getHero();
heroPosition = hero.transform;
}
// Use this for initialization
void Start()
{
action = Director.getInstance().currentSceneControl as IUserAction;
}
public ActionResult Director_Update([DataSourceRequest] DataSourceRequest request, Director model)
{
//throw new Exception("selam");
model.Validate();
if (!model.ValidationErrors.Any())
{
_directorService.Update(model);
return(Json(new[] { model }.ToDataSourceResult(request, ModelState)));
}
else
{
// NOTFINISHED
return(Json(new[] { model }.ToDataSourceResult(request, ModelState)));
}
}
