// Use this for initialization
void Start()
{
try
{
pManager = FindObjectOfType <PlayerManager>();
status = pManager.Status;
alchemy_ctr = FindObjectOfType <AlchemyController>();
alchemyUI_ctr = GameObject.Find("Canvas/Alchemy_UI").GetComponent <AlchemyUIController>();
BrotherObj = FindObjectOfType <MoveController>().gameObject;
move_ctr = BrotherObj.GetComponent <MoveController>();
PotObject = FindObjectOfType <PotController>().gameObject;
createItemBox = new List <CreateItemStatus.Type>();
anim_ctr = BrotherObj.transform.parent.GetComponent <AnimController>();
lifePoint = GameObject.FindGameObjectWithTag("LifePoint");
}
catch (UnityException e)
{
Debug.Log(e + " is NotFound");
}
StartHeart();
setStartSwordList();
//剣のデバッグ
//swordList[1] = PlayerStatus.SWORDTYPE.AXE;
//swordList[2] = PlayerStatus.SWORDTYPE.DARK;
//swordList[3] = PlayerStatus.SWORDTYPE.VAJURA;
_itemMax = false;
alchemyUIFlag = false;
}
void Start()
{
try
{
status = FindObjectOfType <PlayerManager>().Status;
player_ctr = GameObject.Find("Controller").GetComponent <PlayerController>();
move_ctr = GameObject.FindObjectOfType <MoveController>();
crossAxisdown = move_ctr.gameObject.GetComponent <CrossAxisDown>();
alchemy_ctr = GameObject.FindObjectOfType <AlchemyController>();
alchemyText = gameObject.GetComponent <AlchemyText>();
ChooseObj = gameObject.transform.Find("ThrowChoose").gameObject;
ChooseObj.SetActive(false);
ItemFrame = gameObject.transform.Find("SelectFrame").gameObject;
PotFrame = gameObject.transform.Find("AlchemyPotFrame").gameObject;
mtr_0 = PotFrame.transform.Find("AlchemyPotin/Material/material_0").gameObject.transform.GetChild(0).gameObject;
mtr_1 = PotFrame.transform.Find("AlchemyPotin/Material/material_1").gameObject.transform.GetChild(0).gameObject;
AlphaSprite = Resources.Load <Sprite>("Textures/UI/AlphaImage");
SuccessPanel = gameObject.transform.Find("Alchemy_Succes").gameObject;
}
catch (Exception e)
{
Debug.LogWarning(e + "がないよ！");
}
nowAlchemyItem = 0;
nowBox = 0;
beforeNowBox = -1;
_chooseWindow = false;
setItembox();
setItemImageList();
StartCreateItemBox();
Box_item = new GameObject[Itembox.Length];
ClearJoystickRotation();
Materials_item.Clear();
}
public void CanRunCommand()
{
ICommand command = new TestCommand();
ICommunicator com = new TestCommunicator();
AlchemyController con = new AlchemyController( new RuleSet() );
command.Run( "input", con, com );
}
public Do Run( string input, AlchemyController controller, ICommunicator communicator )
{
string elementname = input.TrimStart( '*' );
if( controller.ElementExists( elementname ) )
controller.ForeachNonterminalElement( ( e ) => controller.ReportChangedRule( new Rule( new[] { elementname, e.Name } ) ) );
return Do.AnotherRule;
}
public void AlchemyControllerRecommendsNullIfNoElements()
{
var rs = new RuleSet();
var controller = new AlchemyController( rs );
var rule = controller.RecommendNewRule();
Assert.IsNull( rule );
}
public void DisplayRuleDisplaysNothingIfApplicable()
{
IPreCommand c = new DisplayRecommendedRule();
var rs = new RuleSet();
var a = new AlchemyController( rs );
var t = new TestCommunicator();
t.DisplayCalled += ( o, e ) => Assert.IsTrue( string.IsNullOrEmpty( (string) o ) );
var result = c.Run( a, t );
Assert.AreEqual( Do.KeepProcessing, result );
}
public void AlchemyControllerCanAddNewElement()
{
var rs = new RuleSet();
var controller = new AlchemyController( rs );
const string element = "aoeu";
controller.RegisterNewElement( element );
Assert.AreEqual( 1, rs.FoundElements.Count() );
Assert.AreEqual( element, rs.FoundElements.First().Name );
}
public void AddExplicitRuleWithNewElementsResetsRecommendedElementProgress()
{
var rs = new RuleSet();
var controller = new AlchemyController( rs );
var c = Setup( controller, new[] { ">fire", ">water", "", "", "#fire,fire:energy", "!" } );
c.Cook();
var rule = controller.RecommendNewRule();
Assert.AreEqual( new Rule( new[] { "fire", "energy" } ), rule );
}
static void Main()
{
var filename = ConfigurationManager.AppSettings["filename"];
var serializationTime = Int32.Parse( ConfigurationManager.AppSettings["serializationTime"] );
var rs = FetchRuleSet( filename, serializationTime );
var controller = new AlchemyController( rs );
var communicator = new Communicator();
var chemist = new Chemist( controller, communicator );
chemist.Cook();
}
public void AlchemyControllerRecommendsEmptyRuleIfDone()
{
var rs = new RuleSet();
var controller = new AlchemyController( rs );
controller.RegisterNewElement( "fire" );
var rule = controller.RecommendNewRule();
controller.ReportChangedRule( rule );
var finalRule = controller.RecommendNewRule();
Assert.AreEqual( Rule.EmptyRule, finalRule );
}
public void RuleSetOnlyNotifiesWhenStrictlyNeccessary()
{
var changedprops = new List<string>();
var persister = new XmlPersister( new RuleSetXmlSerializer(), new StreamFactory( "data.xml" ), 2000 );
var rs = persister.RecreateRuleSet();
rs.PropertyChanged += ( s, e ) => changedprops.Add( e.PropertyName );
var controller = new AlchemyController( rs );
var rule = controller.RecommendNewRule();
rule.Result = new[] { new Element( "alpha" ) };
controller.ReportChangedRule( rule );
Assert.AreEqual( 1, changedprops.Count( p => p.Equals( "FoundElements" ) ) );
Assert.AreEqual( 1, changedprops.Count( p => p.Equals( "Rules" ) ) );
}
public void DisplayRuleDisplaysRuleIfApplicable()
{
IPreCommand c = new DisplayRecommendedRule();
var rs = new RuleSet() { FoundElements = TestTools.GenerateElements( 1 ) };
var a = new AlchemyController( rs );
var t = new TestCommunicator();
int count = 0;
t.DisplayCalled += ( o, e ) =>
{
count++;
Assert.IsTrue( ( (string) o ).Contains( "+" ) );
};
var result = c.Run( a, t );
Assert.AreEqual( Do.KeepProcessing, result );
Assert.AreEqual( 1, count );
}
public void RuleSetNotifiesOnPropertyChanged()
{
var changedprops = new List<string>();
var r = new RuleSet();
r.PropertyChanged += ( s, e ) => changedprops.Add( e.PropertyName );
var controller = new AlchemyController( r );
controller.RegisterNewElement( "fire" );
var rule = controller.RecommendNewRule();
rule.Result = new[] { new Element( "water" ) };
controller.ReportChangedRule( rule );
Assert.AreEqual( 2, changedprops.Count( p => p.Equals( "FoundElements" ) ) );
Assert.AreEqual( 2, r.FoundElements.Count() );
Assert.AreEqual( 1, changedprops.Count( p => p.Equals( "Rules" ) ) );
Assert.AreEqual( 1, r.Rules.Count() );
}
public Do Run( string input, AlchemyController controller, ICommunicator communicator )
{
var splitinput = input.TrimStart( ' ', '#' ).Split( ':' );
if( splitinput.Length < 2 )
return Do.AnotherRule;
var ingredients = splitinput[0].Split( ',' );
foreach( var ingredient in ingredients )
{
if( !controller.ElementExists( ingredient ) )
{
communicator.Display( "Bad data, element named '" + ingredient + "' isnt in list of known elements. If this isnt a typo, please add element using '>element', or, if possible, add rule that creates element" );
return Do.AnotherRule;
}
}
var rule = new Rule( ingredients );
rule.SetResult( splitinput[1] );
controller.ReportChangedRule( rule, true );
return Do.AnotherRule;
}
public void AlchemyControllerCanMarkElementAsTerminal()
{
var rs = new RuleSet();
var a = new AlchemyController( rs );
a.RegisterNewElement( "a" );
a.RegisterNewElement( "b" );
a.RegisterNewElement( "c" );
a.RegisterNewElement( "d" );
a.RegisterNewElement( "e" );
a.FinalizeElement( "c" );
var em = rs.FoundElements.FirstOrDefault( e => e.Name.Equals( "c" ) );
Assert.IsTrue( em.TerminalSpecified );
Assert.IsTrue( em.TerminalValue.HasValue );
if( em.TerminalValue != null )
{
Assert.IsTrue( em.TerminalValue.Value );
}
Assert.AreEqual( 1, rs.FoundElements.Count( e => e.TerminalValue.HasValue && e.Terminal ) );
Assert.AreEqual( 4, rs.FoundElements.Count( e => !e.TerminalValue.HasValue ) );
}
public void ControllerCanSayThatItHasFinished()
{
var rs = new RuleSet()
{
FoundElements = new[] { new Element( "fire" ) },
Rules = new[] { new Rule
{
Ingredients = new [] { new Element( "fire" ), new Element("fire") }
}}
};
var c = new AlchemyController( rs );
Assert.AreEqual( AlchemyState.Finished, c.State );
}
public void ControllerCanSayThatItHasStarted()
{
var rs = new RuleSet() { FoundElements = new[] { new Element( "fire" ) } };
var c = new AlchemyController( rs );
Assert.AreEqual( AlchemyState.Started, c.State );
}
public void ControllerRecommendsAllPossibleCombinationsOfElements()
{
const string e1 = "1";
const string e2 = "2";
var rs = new RuleSet();
var c = new AlchemyController( rs );
c.RegisterNewElement( e1 );
c.RegisterNewElement( e2 );
var rules = new List<Rule>();
for( int i = 0; i < 100; i++ )
{
var r1 = c.RecommendNewRule();
if( r1 == Rule.EmptyRule )
break;
rules.Add( r1 );
c.ReportChangedRule( r1 );
}
Assert.AreEqual( 3, rules.Count );
Assert.IsTrue( AssertForCombo( e1, e1, rules ) );
Assert.IsTrue( AssertForCombo( e1, e2, rules ) );
Assert.IsTrue( AssertForCombo( e2, e2, rules ) );
}
public Do Run( string input, AlchemyController controller, ICommunicator communicator )
{
return Do.AnotherRule;
}
public void ControllerRecommendsCombinationsButNotDuplicates()
{
var rs = new RuleSet();
var c = new AlchemyController( rs );
c.RegisterNewElement( "a" );
c.RegisterNewElement( "mb" );
c.RegisterNewElement( "aoeu" );
c.ReportChangedRule( c.RecommendNewRule() );
var rules = new List<Rule>();
for( int i = 0; i < 100; i++ )
{
var r1 = c.RecommendNewRule();
if( r1 == Rule.EmptyRule )
break;
rules.Add( r1 );
c.ReportChangedRule( r1 );
}
Assert.AreEqual( 5, rules.Count );
}
public void RuleOverrideTriggersPropchangedIfRuleChanged()
{
var rs = new RuleSet()
{
FoundElements = new[] { new Element( "fire" ), new Element( "water" ) },
Rules = new[] { new Rule( new[] { "fire", "fire" }, "fire" ) }
};
var c = new AlchemyController( rs );
int count = 0;
rs.PropertyChanged += ( a, e ) => { count++; };
c.ReportChangedRule( new Rule( new[] { "fire", "fire" }, "water" ), true );
Assert.AreEqual( 1, count );
}
public void ControllerCanSayIfHasntStartedYet()
{
var rs = new RuleSet();
var c = new AlchemyController( rs );
Assert.AreEqual( AlchemyState.NotStarted, c.State );
}
public void IsFinishedCommandSaysExitWhenControllerIsDone()
{
var c = new IsFinishedCommand();
var rs = new RuleSet() { FoundElements = TestTools.GenerateElements( 2 ), Rules = TestTools.GenerateRules( 3 ) };
var a = new AlchemyController( rs );
Assert.AreEqual( Do.Exit, c.Run( a, new TestCommunicator() ) );
}
public void IsFinishedCommandSaysContinueIfNotDone()
{
var c = new IsFinishedCommand();
var rs = new RuleSet() { FoundElements = TestTools.GenerateElements( 2 ), Rules = TestTools.GenerateRules( 2 ) };
var a = new AlchemyController( rs );
Assert.AreEqual( Do.KeepProcessing, c.Run( a, new TestCommunicator() ) );
}
public void IsFinishedCommandSaysContinueIfEmptyElementList()
{
var c = new IsFinishedCommand();
var rs = new RuleSet();
var a = new AlchemyController( rs );
Assert.AreEqual( Do.KeepProcessing, c.Run( a, new TestCommunicator() ) );
}
public void ExtensiveControllerRoundtripMonkeyTest()
{
var rs = new RuleSet();
var c = new AlchemyController( rs );
c.RegisterNewElement( "fire" );
c.RegisterNewElement( "water" );
c.RegisterNewElement( "burn" );
}
public void AlchemyControllerRecommendsRule()
{
var rs = new RuleSet
{
FoundElements = new[] { new Element( "fire" ) }
};
var controller = new AlchemyController( rs );
var rule = controller.RecommendNewRule();
Assert.IsNotNull( rule );
Assert.AreEqual( new Rule( new[] { new Element( "fire" ), new Element( "fire" ) } ), rule );
}
public void MultiCommandAddsRules()
{
ICommand command = new AddMultiComboCommand();
var com = new TestCommunicator();
var rs = new RuleSet()
{
FoundElements = new[] { new Element( "fire" ), new Element( "water" ) }
};
var c = new AlchemyController( rs );
command.Run( "*fire", c, com );
Assert.AreEqual( 2, rs.Rules.Length );
}
public Do Run( string input, AlchemyController controller, ICommunicator communicator )
{
communicator.Display( "Exit." );
return Do.Exit;
}
public void PrintCommandWontPrintIrrelevant()
{
ICommand command = new PrintCommand();
var comm = new TestCommunicator();
int count = 0;
comm.DisplayCalled += ( a, e ) =>
{
count++;
};
var rs = new RuleSet()
{
Rules = new[] { new Rule( new[] { "fire", "water" }, "water" ) }
};
var controller = new AlchemyController( rs );
command.Run( "?fire3", controller, comm );
Assert.AreEqual( 0, count );
}
public void AlchemyControllerWontReccomendRuleWithTerminalElements()
{
var rs = new RuleSet();
var a = new AlchemyController( rs );
a.RegisterNewElement( "a" );
a.RegisterNewElement( "b" );
a.RegisterNewElement( "c" );
a.FinalizeElement( "a" );
var rules = new List<Rule>();
for( int i = 0; i < 100; i++ )
{
var r1 = a.RecommendNewRule();
if( r1 == Rule.EmptyRule )
break;
rules.Add( r1 );
a.ReportChangedRule( r1 );
}
Assert.AreEqual( 3, rules.Count );
Assert.IsFalse( rules.Any( r => r.Ingredients.Any( i => i.Name.Equals( a ) ) ) );
}
void TestControllerForRules( int elements, int rules )
{
var rs = new RuleSet()
{
FoundElements = TestTools.GenerateElements( elements ),
Rules = TestTools.GenerateRules( rules )
};
var c = new AlchemyController( rs );
Assert.AreEqual( AlchemyState.Finished, c.State );
}
