public void Setup()
{
this.Type = typeof(MockObject);
this.Dependencies = new List <Dependency>();
this.ConstructorFilter = Substitute.For <IConstructorFilter>();
this.Target = new TargetFactory <MockObject>(this.ConstructorFilter);
}
private RandomizedTester(TargetFactory <T> targetFactory, ActionFactory <T, F> actionFactory, Action <T, F> failingAction, F failure)
{
this._targetFactory = targetFactory;
this._actionFactory = actionFactory;
this._failingAction = failingAction;
this._failure = failure;
}
private static RegisterCompleteEventArgs RegisterEx(string message, List <ICheckpoint> checkpoints, string userHandle, IDictionary <string, string> data, Action <RegisterCompleteEventArgs> completeAction)
{
RegisterCompleteEventArgs registerCompleteEventArgs = null;
try
{
var target = TargetFactory.Get();
var response = target.RegisterCounter(new CounterData(Guid.NewGuid(), DateTime.UtcNow, Session.GetSessionData(), userHandle, message, data, checkpoints));
Session.RegisteredOnServer = true; //TODO: This is true, also if an issue has been returned from the server
registerCompleteEventArgs = new RegisterCompleteEventArgs(true, response);
}
catch (InvalidOperationException exception)
{
registerCompleteEventArgs = new RegisterCompleteEventArgs(false, exception);
}
catch (Exception exception)
{
registerCompleteEventArgs = new RegisterCompleteEventArgs(false, exception);
}
finally
{
InvokeRegisterComplete(registerCompleteEventArgs);
}
if (completeAction != null)
{
completeAction.Invoke(registerCompleteEventArgs);
}
_registerCompleteEventArgs = registerCompleteEventArgs;
return(registerCompleteEventArgs);
}
/*********
** Public methods
*********/
/// <summary>Construct an instance.</summary>
/// <param name="gameHelper">Provides utility methods for interacting with the game code.</param>
/// <param name="targetFactory">Finds and analyzes lookup targets in the world.</param>
/// <param name="config">The mod configuration.</param>
/// <param name="monitor">Encapsulates monitoring and logging.</param>
public DebugInterface(GameHelper gameHelper, TargetFactory targetFactory, Func <ModConfig> config, IMonitor monitor)
{
this.GameHelper = gameHelper;
this.TargetFactory = targetFactory;
this.Config = config;
this.Monitor = monitor;
}
private static RegisterCompleteEventArgs RegisterEx(Func <ISessionData> data)
{
RegisterCompleteEventArgs registerCompleteEventArgs = null;
try
{
AssureSessionData();
var target = TargetFactory.Get();
target.RegisterSession(data());
registerCompleteEventArgs = new RegisterCompleteEventArgs(true);
_registeredOnServer = true; //TODO: This is true, also if an issue has been returned from the server. (Even though the session was never started explicitly)
}
catch (InvalidOperationException exception)
{
registerCompleteEventArgs = new RegisterCompleteEventArgs(true, exception);
}
catch (Exception exception)
{
registerCompleteEventArgs = new RegisterCompleteEventArgs(false, exception);
}
finally
{
InvokeRegisterComplete(registerCompleteEventArgs);
}
_registerCompleteEventArgs = registerCompleteEventArgs;
return(registerCompleteEventArgs);
}
private Target WrapWithDefaultWrapper(Target t, XmlElement defaultWrapperElement)
{
string wrapperType = GetCaseInsensitiveAttribute(defaultWrapperElement, "type");
Target wrapperTargetInstance = TargetFactory.CreateTarget(wrapperType);
WrapperTargetBase wtb = wrapperTargetInstance as WrapperTargetBase;
if (wtb == null)
{
throw new NLogConfigurationException("Target type specified on <default-wrapper /> is not a wrapper.");
}
ConfigureTargetFromXmlElement(wrapperTargetInstance, defaultWrapperElement);
while (wtb.WrappedTarget != null)
{
wtb = wtb.WrappedTarget as WrapperTargetBase;
if (wtb == null)
{
throw new NLogConfigurationException("Child target type specified on <default-wrapper /> is not a wrapper.");
}
}
wtb.WrappedTarget = t;
wrapperTargetInstance.Name = t.Name;
t.Name = t.Name + "_wrapped";
InternalLogger.Debug("Wrapping target '{0}' with '{1}' and renaming to '{2}", wrapperTargetInstance.Name, wrapperTargetInstance.GetType().Name, t.Name);
return(wrapperTargetInstance);
}
public TTargetModel Bind(string topic)
{
if (RegisteredVariables.Count == 0)
{
return(TargetFactory());
}
var match = RegexPattern.Match(topic);
if (!match.Success)
{
throw new ArgumentException("The supplied topic did not match the configured pattern");
}
var target = TargetFactory.Invoke();
foreach (var registeredVariable in RegisteredVariables)
{
var value = match.Groups[registeredVariable].Value;
var setter = PropertySetters[registeredVariable];
setter.Invoke(target, value);
}
return(target);
}
/// <summary>
/// Posts the specified network response.
/// </summary>
/// <param name="networkResponse">The network response to post.</param>
public static void PostNetworkResponse(NetworkResponse networkResponse)
{
if (networkResponse == null)
{
return;
}
TargetFactory.HandleNetworkResponse(networkResponse);
}
internal TestCaseWriter(string testName, Printable given, TargetFactory <T> targetFactory, IList <Action <T, F> > actions, Action <T, F> failingAction)
{
this._testName = testName;
this._given = given;
this._targetFactory = targetFactory;
this._actions = actions;
this._failingAction = failingAction;
}
private void ConfigureTargetFromXmlElement(Target target, XmlElement element)
{
NLog.Targets.Compound.CompoundTargetBase compound = target as NLog.Targets.Compound.CompoundTargetBase;
NLog.Targets.Wrappers.WrapperTargetBase wrapper = target as NLog.Targets.Wrappers.WrapperTargetBase;
PropertyHelper.ConfigureObjectFromAttributes(target, element.Attributes, _variables, true);
foreach (XmlElement el in PropertyHelper.GetChildElements(element))
{
string name = el.LocalName;
if (compound != null)
{
if ((name == "target" || name == "wrapper" || name == "wrapper-target" || name == "compound-target"))
{
string type = GetCaseInsensitiveAttribute(el, "type");
Target newTarget = TargetFactory.CreateTarget(type);
if (newTarget != null)
{
ConfigureTargetFromXmlElement(newTarget, el);
if (newTarget.Name != null)
{
// if the new target has name, register it
AddTarget(newTarget.Name, newTarget);
}
compound.Targets.Add(newTarget);
}
continue;
}
}
if (wrapper != null)
{
if ((name == "target" || name == "wrapper" || name == "wrapper-target" || name == "compound-target"))
{
string type = GetCaseInsensitiveAttribute(el, "type");
Target newTarget = TargetFactory.CreateTarget(type);
if (newTarget != null)
{
ConfigureTargetFromXmlElement(newTarget, el);
if (newTarget.Name != null)
{
// if the new target has name, register it
AddTarget(newTarget.Name, newTarget);
}
if (wrapper.WrappedTarget != null)
{
throw new NLogConfigurationException("Wrapped target already defined.");
}
wrapper.WrappedTarget = newTarget;
}
continue;
}
}
PropertyHelper.SetPropertyFromElement(target, el, _variables);
}
}
/*********
** Public methods
*********/
/// <summary>Construct an instance.</summary>
/// <param name="targetFactory">Finds and analyses lookup targets in the world.</param>
/// <param name="config">The mod configuration.</param>
/// <param name="monitor">Encapsulates monitoring and logging.</param>
public DebugInterface(TargetFactory targetFactory, ModConfig config, IMonitor monitor)
{
// save fields
this.TargetFactory = targetFactory;
this.Monitor = monitor;
// generate warning text
this.WarningText = $"Debug info enabled; press {string.Join(" or ", config.Controls.ToggleDebug)} to disable.";
}
private void ConfigureTargetsFromElement(XmlElement element)
{
if (element == null)
{
return;
}
bool asyncWrap = EqualsCI(GetCaseInsensitiveAttribute(element, "async"), "true");
XmlElement defaultWrapperElement = null;
Hashtable typeNameToDefaultTargetParametersElement = new Hashtable();
foreach (XmlElement targetElement in PropertyHelper.GetChildElements(element))
{
string name = targetElement.LocalName.ToLower();
string type = GetCaseInsensitiveAttribute(targetElement, "type");
switch (name)
{
case "default-wrapper":
defaultWrapperElement = targetElement;
break;
case "default-target-parameters":
typeNameToDefaultTargetParametersElement[type] = targetElement;
break;
case "target":
case "appender":
case "wrapper":
case "wrapper-target":
case "compound-target":
Target newTarget = TargetFactory.CreateTarget(type);
XmlElement defaultParametersElement = typeNameToDefaultTargetParametersElement[type] as XmlElement;
if (defaultParametersElement != null)
{
ConfigureTargetFromXmlElement(newTarget, defaultParametersElement);
}
ConfigureTargetFromXmlElement(newTarget, targetElement);
if (asyncWrap)
{
newTarget = WrapWithAsyncTarget(newTarget);
}
if (defaultWrapperElement != null)
{
newTarget = WrapWithDefaultWrapper(newTarget, defaultWrapperElement);
}
InternalLogger.Info("Adding target {0}", newTarget);
AddTarget(newTarget.Name, newTarget);
break;
}
}
}
internal static T GetNativeObject <T>(object obj, string objName)
where T : class
{
if (typeof(T) != typeof(UIViewController) && obj == null)
{
return(null);
}
return(TargetFactory.GetNativeObject(obj, objName, typeof(T)) as T);
}
public MultyPlayerShootOut(int seed = 0, TargetTypes allowed = TargetTypes.None) : base(seed, allowed)
{
targets = new List <Target>();
targetFactory = new TargetFactory();
targetFactory.TargetTypesAllowed = this.TargetTypesAllowed;
targetFactory.random = new Random(this.seed);
targetFactory.actieTargets = this.targets;
publisher = new Publisher();
}
public void TargetFactory_GetInstance_Test()
{
// Setup
TargetFactory tf = new TargetFactory();
GameObject instance = tf.GetInstance(new GameObject("Target"));
// Confirm the instance was return
Debug.Log(instance.name);
Assert.AreEqual("Target(Clone)", instance.name);
}
/*********
** Public methods
*********/
/// <summary>Construct an instance.</summary>
/// <param name="targetFactory">Finds and analyses lookup targets in the world.</param>
/// <param name="config">The mod configuration.</param>
public DebugInterface(TargetFactory targetFactory, ModConfig config)
{
// save factory
this.TargetFactory = targetFactory;
// generate warning text
string[] keys = new[] { config.Keyboard.IsValidKey(config.Keyboard.ToggleDebug) ? config.Keyboard.ToggleDebug.ToString() : null, config.Controller.IsValidKey(config.Controller.ToggleDebug) ? config.Controller.ToggleDebug.ToString() : null }
.Where(p => p != null)
.ToArray();
this.WarningText = $"Debug info enabled; press {string.Join(" or ", keys)} to disable.";
}
static public IBookTarget BuildTargetFromElement(IBookIndex element, ITargetValues values, IProcessConfig config)
{
uint articleCode = element.Code();
IPayrollArticle targetArticle = config.FindArticle(articleCode);
IPayrollConcept targetConcept = config.FindConcept(targetArticle.ConceptCode());
IBookTarget target = TargetFactory.BuildTargetWithValues(element, targetArticle, targetConcept, values);
return(target);
}
void Awake()
{
if (instance == null)
{
instance = this;
DontDestroyOnLoad(this.gameObject);
}
else
{
Destroy(this);
}
ClearTargets();
}
/*********
** Private methods
*********/
/// <summary>The method invoked on the first update tick, once all mods are initialised.</summary>
/// <param name="sender">The event sender.</param>
/// <param name="e">The event data.</param>
private void GameEvents_FirstUpdateTick(object sender, EventArgs e)
{
// initialise functionality
this.GameHelper = new GameHelper();
this.TargetFactory = new TargetFactory(this.Helper.Reflection, this.GameHelper);
this.DebugInterface = new DebugInterface(this.GameHelper, this.TargetFactory, this.Config, this.Monitor);
// hook up events
//TimeEvents.AfterDayStarted += this.TimeEvents_AfterDayStarted;
InputEvents.ButtonPressed += this.InputEvents_ButtonPressed;
GraphicsEvents.OnPostRenderHudEvent += this.GraphicsEvents_OnPostRenderHudEvent;
GraphicsEvents.OnPostRenderEvent += this.GraphicsEvents_OnPostRenderEvent;
}
/*********
** Public methods
*********/
/// <summary>The mod entry point, called after the mod is first loaded.</summary>
/// <param name="helper">Provides methods for interacting with the mod directory, such as read/writing a config file or custom JSON files.</param>
public override void Entry(IModHelper helper)
{
// load config
this.Config = this.Helper.ReadConfig <ModConfig>();
// load database
this.LoadMetadata();
#if TEST_BUILD
this.OverrideFileWatcher = new FileSystemWatcher(this.PathOnDisk, this.DatabaseFileName)
{
EnableRaisingEvents = true
};
this.OverrideFileWatcher.Changed += (sender, e) =>
{
this.LoadMetadata();
this.TargetFactory = new TargetFactory(this.Metadata);
this.DebugInterface = new DebugInterface(this.TargetFactory, this.Config)
{
Enabled = this.DebugInterface.Enabled
};
};
#endif
// initialise functionality
this.TargetFactory = new TargetFactory(this.Metadata, this.Helper.Translation, this.Helper.Reflection);
this.DebugInterface = new DebugInterface(this.TargetFactory, this.Config, this.Monitor);
// hook up events
TimeEvents.AfterDayStarted += this.TimeEvents_AfterDayStarted;
GraphicsEvents.OnPostRenderHudEvent += this.GraphicsEvents_OnPostRenderHudEvent;
MenuEvents.MenuClosed += this.MenuEvents_MenuClosed;
InputEvents.ButtonPressed += this.InputEvents_ButtonPressed;
if (this.Config.HideOnKeyUp)
{
InputEvents.ButtonReleased += this.InputEvents_ButtonReleased;
}
// validate metadata
this.IsDataValid = this.Metadata.LooksValid();
if (!this.IsDataValid)
{
this.Monitor.Log("The data.json file seems to be missing or corrupt. Lookups will be disabled.", LogLevel.Error);
this.IsDataValid = false;
}
// validate translations
if (!helper.Translation.GetTranslations().Any())
{
this.Monitor.Log("The translation files in this mod's i18n folder seem to be missing. The mod will still work, but you'll see 'missing translation' messages. Try reinstalling the mod to fix this.", LogLevel.Warn);
}
}
/*********
** Private methods
*********/
/****
** Event handlers
****/
/// <summary>The method invoked on the first update tick, once all mods are initialised.</summary>
/// <param name="sender">The event sender.</param>
/// <param name="e">The event data.</param>
private void OnGameLaunched(object sender, GameLaunchedEventArgs e)
{
if (!this.IsDataValid)
{
return;
}
// initialise functionality
var customFarming = new CustomFarmingReduxIntegration(this.Helper.ModRegistry, this.Monitor);
this.GameHelper = new GameHelper(customFarming);
this.TargetFactory = new TargetFactory(this.Metadata, this.Helper.Translation, this.Helper.Reflection, this.GameHelper);
this.DebugInterface = new DebugInterface(this.GameHelper, this.TargetFactory, this.Config, this.Monitor);
}
/// <summary>
/// Raises the event.
/// </summary>
/// <param name="handler">The delegate to invoke.</param>
/// <param name="sender">The sender.</param>
/// <param name="eventArgs">The <see cref="EventArgs"/> instance containing the event data.</param>
public static void Raise(this Delegate handler, object sender, EventArgs eventArgs)
{
if (handler == null)
{
return;
}
try
{
handler.GetMethodInfo()
.Invoke(handler.Target, new[] { TargetFactory.GetPair(sender), eventArgs });
}
catch (TargetInvocationException e)
{
throw new TargetInvocationException("Please check the inner exception for error details.", e.InnerException);
}
}
public MultyPlayerShootOut(MultyPlayerShootOut copy) : base()
{
targets = new List <Target>(copy.targets);
TargetTypesAllowed = copy.TargetTypesAllowed;
players = new Dictionary <string, Shooter>(copy.players);
this.seed = copy.seed;
this.TargetTypesAllowed = copy.TargetTypesAllowed;
this.publisher = copy.publisher;
//Target factory
targetFactory = new TargetFactory();
targetFactory.actieTargets = this.targets;
targetFactory.random = new Random(this.seed);
targetFactory.TargetTypesAllowed = copy.TargetTypesAllowed;
}
public void TargetFactory_CalculateInstanceLocation_Test()
{
// Setup
TargetFactory tf = new TargetFactory();
// Confirm that CalculateInstanceLocation returns a random set bween bounds
Vector3 center = new Vector3(50, 50, 50);
Vector3 dimensions = new Vector3(50, 50, 50);
Vector3 randomPos = tf.CalculateInstanceLocation(center, dimensions);
Assert.Greater(randomPos.x, 0);
Assert.Greater(randomPos.y, 0);
Assert.Greater(randomPos.z, 0);
Assert.Less(randomPos.x, 100);
Assert.Less(randomPos.y, 100);
Assert.Less(randomPos.z, 100);
}
internal static T GetNativeObject <T>(object obj, string objName, bool allowNull)
where T : class
{
if (allowNull && obj == null)
{
return(null);
}
obj = TargetFactory.GetNativeObject(obj, objName, typeof(T), typeof(ISealedElement));
var seal = obj as ISealedElement;
if (seal != null)
{
return(seal.Element as T);
}
return(obj as T);
}
public virtual void ReadDeviceState(C64Interfaces.IFile stateFile)
{
_state.A.Value = stateFile.ReadByte();
_state.X.Value = stateFile.ReadByte();
_state.Y.Value = stateFile.ReadByte();
_state.PC.Value = stateFile.ReadWord();
_state.S.Value = stateFile.ReadWord();
_state.P.Value = stateFile.ReadByte();
_opcode = stateFile.ReadByte();
_result = stateFile.ReadByte();
_target = TargetFactory.ReadTargetFromStateFile(this, stateFile);
_irq.ReadDeviceState(stateFile);
_nmi.ReadDeviceState(stateFile);
}
/*********
** Private methods
*********/
/****
** Event handlers
****/
/// <summary>The method invoked on the first update tick, once all mods are initialized.</summary>
/// <param name="sender">The event sender.</param>
/// <param name="e">The event data.</param>
private void OnGameLaunched(object sender, GameLaunchedEventArgs e)
{
if (!this.IsDataValid)
{
return;
}
// get mod APIs
JsonAssetsIntegration jsonAssets = new JsonAssetsIntegration(this.Helper.ModRegistry, this.Monitor);
// initialize functionality
var customFarming = new CustomFarmingReduxIntegration(this.Helper.ModRegistry, this.Monitor);
var producerFramework = new ProducerFrameworkModIntegration(this.Helper.ModRegistry, this.Monitor);
this.GameHelper = new GameHelper(customFarming, producerFramework, this.Metadata);
this.TargetFactory = new TargetFactory(this.Helper.Reflection, this.GameHelper, jsonAssets, new SubjectFactory(this.Metadata, this.Helper.Translation, this.Helper.Reflection, this.GameHelper, this.Config));
this.DebugInterface = new DebugInterface(this.GameHelper, this.TargetFactory, this.Config, this.Monitor);
}
/// <summary>
/// ロガーを初期化します。
/// </summary>
static Log()
{
try
{
var thisAsm = Assembly.GetExecutingAssembly();
var entryAsm = Assembly.GetEntryAssembly();
// ロガーを作成する前に、必要なオブジェクトを
// 読み込んでおきます。
TargetFactory.AddTargetsFromAssembly(thisAsm, "");
LayoutFactory.AddLayoutsFromAssembly(thisAsm, "");
LayoutRendererFactory.AddLayoutRenderersFromAssembly(thisAsm, "");
// 実行ファイルと同じパスからappname.exe.nlogやNLog.configを検索します。
var configFileNames = new string[]
{
Path.GetFileName(entryAsm.CodeBase) + ".nlog",
"NLog.config",
};
var basePath = Path.GetDirectoryName(entryAsm.Location);
foreach (var configFile in configFileNames)
{
var filename = Path.Combine(basePath, configFile);
if (!File.Exists(filename))
{
continue;
}
LogManager.Configuration =
new XmlLoggingConfiguration(filename);
break;
}
logger = LogManager.GetCurrentClassLogger();
// 最後に未処理の例外ハンドラを追加します。
AppDomain.CurrentDomain.UnhandledException += UnhandledException;
}
catch
{
// どうしよう。。。
}
}
public void setTargetSpawn()
{
//targetContainer.targets [itemIndex].typeofTarget
Debug.Log("Called: " + itemIndex);
switch (targetContainer.targets [itemIndex].typeofTarget)
{
case Target.Pojo.TargetType.CUBE:
{
GameObject cubeTarget = Instantiate(TargetFactory.getTarget(Target.Pojo.TargetType.CUBE).spawnPrefub(), spawnPoints [Random.Range(0, spawnPoints.Length)].transform);
Color color = new Color();
color.r = targetContainer.targets [itemIndex].color [0];
color.g = targetContainer.targets [itemIndex].color [1];
color.b = targetContainer.targets [itemIndex].color [2];
cubeTarget.transform.GetChild(0).gameObject.AddComponent <CubeTarget> ().setColor(color);
cubeTarget.transform.GetChild(0).gameObject.GetComponent <CubeTarget> ().setPointValue(targetContainer.targets [itemIndex].pointValue);
}
break;
case Target.Pojo.TargetType.SPHERE:
{
GameObject sphere = Instantiate(TargetFactory.getTarget(Target.Pojo.TargetType.SPHERE).spawnPrefub(), spawnPoints [Random.Range(0, spawnPoints.Length)].transform);
Color color = new Color();
color.r = targetContainer.targets [itemIndex].color [0];
color.g = targetContainer.targets [itemIndex].color [1];
color.b = targetContainer.targets [itemIndex].color [2];
sphere.transform.GetChild(0).gameObject.AddComponent <SphereTarget> ().setColor(color);
sphere.transform.GetChild(0).gameObject.GetComponent <SphereTarget> ().setPointValue(targetContainer.targets [itemIndex].pointValue);
}
break;
case Target.Pojo.TargetType.CAPSULE:
{
GameObject capsule = Instantiate(TargetFactory.getTarget(Target.Pojo.TargetType.CAPSULE).spawnPrefub(), spawnPoints [Random.Range(0, spawnPoints.Length)].transform);
Color color = new Color();
color.r = targetContainer.targets [itemIndex].color [0];
color.g = targetContainer.targets [itemIndex].color [1];
color.b = targetContainer.targets [itemIndex].color [2];
capsule.transform.GetChild(0).gameObject.AddComponent <CapsuleTarget> ().setColor(color);
capsule.transform.GetChild(0).gameObject.GetComponent <CapsuleTarget> ().setPointValue(targetContainer.targets [itemIndex].pointValue);
}
break;
}
}
public override void _Ready()
{
rf = (RocketFactory)GetChild(0);
of = (ObstacleFactory)GetChild(1);
tf = (TargetFactory)GetChild(2);
rockets = rf.createPopulation(References.populationSize);
obstacles = of.createPopulation(References.obstaclePopulationSize);
target = tf.createTarget();
populationDead = false;
time = 0;
maxFitnessAchieved = 0;
for (int i = 0; i < rockets.Length; i++)
{
rockets[i].SetTarget(target);
}
genePool = new List <Instruction[]>();
fitnessHistory = new List <string>();
infoText = (RichTextLabel)GetNode("/root/MainScene/UI/InfoText");
}
