public override void Execute()
{
ExecuteMethod.OnceInUpdate("SquadChildFSM.UpdateLandmineList", null, null);
m_scFSM.Strafing();
// if: There is more landmine than the production child count
if (SquadChildFSM.ListLandmine.Count >= SquadChildFSM.StateCount(SCState.Produce))
{
for (int i = 0; i < SquadChildFSM.ListLandmine.Count; i++)
{
if (Vector3.Distance(SquadChildFSM.ListLandmine[i].transform.position, m_scFSM.transform.position) < 2f)
{
m_scFSM.Advance(SCState.Avoid);
return;
}
}
}
// else if: There is lesser landmine state BUT not 0
else if (SquadChildFSM.ListLandmine.Count != 0)
{
for (int i = 0; i < SquadChildFSM.ListLandmine.Count; i++)
{
if (Vector3.Distance(SquadChildFSM.ListLandmine[i].transform.position, m_scFSM.transform.position) < 2f)
{
m_scFSM.Advance(SCState.Attack);
return;
}
}
}
}
private void Execute(ExecuteMethod executeMethod)
{
if (IsExecuteMethodSelected(executeMethod))
{
Execute();
}
}
public State(ExecuteMethod executeMethod, DecideMethod decideMethod, EnterMethod enterMethod, ExitMethod exitMethod)
{
this.executeMethod = executeMethod;
this.decideMethod = decideMethod;
this.enterMethod = enterMethod;
this.exitMethod = exitMethod;
}
internal static void TestExecuteSourcesNoInput(string[] sources, string baseline, string testname, ExecuteMethod method)
{
LOLCodeCodeProvider provider = new LOLCodeCodeProvider();
string assemblyName = String.Format("{0}.exe", testname);
CompilerParameters cparam = GetDefaultCompilerParams(assemblyName, method);
// Compile test
CompilerResults results = provider.CompileAssemblyFromSourceBatch(cparam, sources);
// Collect errors (if any)
StringBuilder errors = new StringBuilder();
if (results.Errors.HasErrors)
{
for (int i = 0; i < results.Errors.Count; i++)
{
errors.AppendLine(results.Errors[i].ToString());
}
}
// Ensure there are no errors before trying to execute
Assert.AreEqual(0, results.Errors.Count, errors.ToString());
if (method == ExecuteMethod.InMemory)
{
throw new NotImplementedException("In memory execution is not implimented yet");
}
else
{
// Run the executeable (collecting it's output) compare to baseline
Assert.AreEqual(baseline, RunExecuteable(assemblyName));
File.Delete(assemblyName);
}
}
// Execute(): When the squad child is in this state. Runs once every frame on every instance
public override void Execute()
{
// Calculates the velocity for all children
ExecuteMethod.OnceInUpdate("SC_IdleState.CalculateVelocity", null, null);
// toTargetVector: The vector from its tranform position to the angular position
Vector3 toTargetVector = PlayerSquadFSM.Instance.transform.position + Quaternion.Euler(0.0f, 0.0f, fAngularPosition) * Vector3.up * s_fIdleRadius - m_scFSM.transform.position;
if (toTargetVector.magnitude > s_fIdleRigidity)
{
m_scFSM.m_RigidBody.AddForce(toTargetVector);
}
m_scFSM.m_RigidBody.velocity = Vector3.ClampMagnitude(m_scFSM.m_RigidBody.velocity, Mathf.Max(s_fIdleRigidity, toTargetVector.magnitude));
fAngularPosition += fAngularVelocity * Time.deltaTime;
// if, else if: Clamping values to be within 0 to 360f
if (fAngularPosition > 360.0f)
{
fAngularPosition -= 360.0f;
}
else if (fAngularPosition < 0.0f)
{
fAngularPosition += 360.0f;
}
}
public ExecuteMethod GetExecuteMethodDescriptor(string name, Type returnType, params object[] arg)
{
/*byte[][] arguments = null;
* if ((arg?.Length??0) > 0)
* {
* arguments = new byte[arg.Length][];
* using (var mm = MemoryManager.Instance.GetStream())
* {
* int i = 0;
* foreach (var a in arg)
* {
* mm.SetLength(0);
* Host.Serializer.Serialize(a, mm, out _);
* arguments[i++] = mm.ToArray();
* }
* }
*
* }*/
var exe = new ExecuteMethod
{
Eid = _Eid,
//Arguments = arguments,
Method = name,
//_ReturnType = returnType
Objects = arg
};
return(exe);
}
public State(ExecuteMethod executeMethod, DecideMethod decideMethod, EnterMethod enterMethod, ExitMethod exitMethod)
{
this.executeMethod = executeMethod;
this.decideMethod = decideMethod;
this.enterMethod = enterMethod;
this.exitMethod = exitMethod;
}
protected void Execute(ExecuteMethod executeMethod)
{
if (IsExecuteMethodSelected(executeMethod))
{
Execute();
}
}
public MethodDescriptor FindOverload(ExecuteMethod cmd)
{
foreach (var m in _methods[cmd.Method])
{
if (/*cmd._ReturnType.IsAssignableFrom(m.RealReturnType) &&*/
m.Parameters.Length == (cmd.Objects?.Length ?? 0))
{
var i = 0;
var err = false;
for (; i < m.Parameters.Length; i++)
{
var type = cmd.Objects[i]?.GetType();
if (type != null && !m.Parameters[i].Type.IsAssignableFrom(type))
{
err = true;
break;
}
}
if (err)
{
continue;
}
return(m);
}
}
return(null);
}
public void CommandExecute(ProxyDbCommand command, TimeSpan duration, ExecuteMethod method, List<QueryExecutionPlan> executionPlan, object result)
{
if (!IsAvailable()) return;
var commandMessage = new CommandMessage(command.CommandText, duration, method.ToString(), command.ProxyDbConnection.Context) { QueryExecutionPlans = executionPlan };
GetChannel().CommandExecute(commandMessage);
}
private ppStage(string id, string name, ExecuteMethod method, bool isReceiveStage)
{
_id = new Guid(id);
_name = name;
_executeMethod = method;
_isReceiveStage = isReceiveStage;
_stages.Add(_id, this);
}
private PipelineStage(string id, string name, ExecuteMethod method, bool isReceiveStage)
{
_id = new Guid(id);
_name = name;
_executeMethod = method;
_isReceiveStage = isReceiveStage;
_stages.Add(_id, this);
}
/// <summary>
/// Initializes a new instance of the <see cref="DelegateCommand"/> class.
/// </summary>
/// <param name="exec">The execute method</param>
/// <param name="canExecutePredicate">Predicate Function without object parameter</param>
public DelegateCommand(ExecuteMethod exec, Func <bool> canExecutePredicate)
: this(exec)
{
canExecute = (obj) =>
{
return(canExecutePredicate.Invoke());
};
}
public Command(string keyword, string description, bool echoCommand, Parameter[] parameters, ExecuteMethod method)
{
this.keyword = keyword;
this.description = description;
this.echoCommand = echoCommand;
this.parameters = parameters;
this.method = method;
}
public Command(string keyword, string description, ExecuteMethod method)
{
this.keyword = keyword;
this.description = description;
this.method = method;
parameters = new Parameter[0];
echoCommand = true;
}
/// <summary>
/// Instantiates a new RelayCommand with a delegate to be executed when the command is called, and a predicate to check if the command can be called.
/// </summary>
/// <param name="execute">The method to be exeucted when the command is called.</param>
/// <param name="canExecute">The predicate to check if the command is callable.</param>
public RelayCommand(ExecuteMethod execute, CanExecuteMethod canExecute)
{
if (execute == null)
{
throw new ArgumentNullException("execute");
}
_execute = execute;
_canExecute = canExecute;
}
private static CompilerParameters GetDefaultCompilerParams(string outfile, ExecuteMethod method)
{
CompilerParameters cparam = new CompilerParameters();
cparam.GenerateExecutable = true;
cparam.GenerateInMemory = (method == ExecuteMethod.InMemory) ? true : false;
cparam.OutputAssembly = outfile;
cparam.MainClass = "Program";
cparam.IncludeDebugInformation = true;
return cparam;
}
public override void Execute()
{
if (m_scFSM.attackTarget != null && !isColorChanged)
{
m_scFSM.m_SpriteRenderer.color = new Color(1f, 0.12f, 0.12f);
isColorChanged = true;
}
ExecuteMethod.OnceInUpdate("SquadChildFSM.GetNearestTargetPosition", null, null);
m_scFSM.AttackTarget();
}
public void FillInvocation(ExecuteMethod cmd, MethodDescriptor descriptor)
{
for (int i = 0; i < cmd.Objects.Length; i++)
{
var type = descriptor.Parameters[i].Type;
if (descriptor.Parameters[i].IsDummy || (type.GetTypeInfo().IsValueType&& cmd.Objects[i] == null))
{
cmd.Objects[i] = Activator.CreateInstance(type);
}
}
}
private static CompilerParameters GetDefaultCompilerParams(string outfile, ExecuteMethod method)
{
CompilerParameters cparam = new CompilerParameters();
cparam.GenerateExecutable = true;
cparam.GenerateInMemory = (method == ExecuteMethod.InMemory) ? true : false;
cparam.OutputAssembly = outfile;
cparam.MainClass = "Program";
cparam.IncludeDebugInformation = true;
return(cparam);
}
public Stage(string name, ExecuteMethod executeMethod, Guid id, IPipeline pipeline)
{
if (pipeline == null)
{
throw new ArgumentNullException("pipeline");
}
this.name = name;
this.executeMethod = executeMethod;
this.id = id;
this.pipeline = pipeline;
}
private void EnableExecuteButton(bool enable, int imageIndex)
{
if (gridNavigator.InvokeRequired)
{
EnableExecuteButtonEvent d = new EnableExecuteButtonEvent(this.EnableExecuteButton);
this.Invoke(d, new object[] { enable, imageIndex });
}
else
{
toolStripButtonExecute.Image = ilExecute.Images[imageIndex];
_executeMethod = (ExecuteMethod)imageIndex;
toolStripButtonExecute.Enabled = enable;
}
}
private void method_10(IConnection iconnection_1, object object_1, Type type_0)
{
Controller.logger_0.Info("Received payload of type {type}", type_0.FullName);
ExecuteMethod executeMethod = object_1 as ExecuteMethod;
if (executeMethod != null)
{
Controller.logger_0.Info("method: {method}", executeMethod.Method);
return;
}
EntangleResult entangleResult = object_1 as EntangleResult;
if (entangleResult != null)
{
Controller.logger_0.Info <Guid?>("Entangled type: {type}", entangleResult.Eid);
}
}
// Strafing(): Handles the movement when the cells are in production state
public bool Strafing()
{
if (m_currentEnumState != SCState.Produce)
{
Debug.LogWarning(gameObject.name + ".SquadChildFSM.Strafing(): Current state is not SCState.Produce! Ignore Strafing!");
return(false);
}
ExecuteMethod.OnceInUpdate("SquadChildFSM.StrafingVector", null, null);
// targetPosition: The calculated target position - includes its angular offset from the main vector and the squad's captain position
Vector3 targetPosition = Quaternion.Euler(0.0f, 0.0f, fStrafingOffsetAngle) * m_strafingVector + PlayerSquadFSM.Instance.transform.position;
Vector3 toTargetPosition = targetPosition - transform.position;
m_RigidBody.AddForce(toTargetPosition.normalized, ForceMode2D.Impulse);
m_RigidBody.velocity = Vector3.ClampMagnitude(m_RigidBody.velocity, toTargetPosition.magnitude * 3f);
return(true);
}
/// <inheritdoc />
public override void Execute(object parameter = null)
{
if (!CanExecute())
{
return;
}
IsExecuting = true;
try
{
ExecuteMethod?.Invoke();
}
finally
{
IsExecuting = false;
}
}
// 初期化処理など
void Start()
{
// ターゲットのFPSを指定します
Application.targetFrameRate = targetFps;
Screen.sleepTimeout = SleepTimeout.NeverSleep;
if (isLowResolution)
{
Screen.SetResolution(Screen.width / 4, Screen.height / 4, true);
}
// デフォルト挙動セット
this.executeMethod = this.defaultMode;
Resources.FindObjectsOfTypeAll <UnityEngine.UI.Dropdown>()[0].value = (int)this.defaultMode;
// ログファイル名指定
BatteryLogger.Instance.LogFile = this.logFileName;
// 操作対象のtransformの作成を行います
transformArray = new Transform[objectNum];
for (int i = 0; i < objectNum; ++i)
{
GameObject gmo = Object.Instantiate <GameObject>(prefab);
transformArray[i] = gmo.transform;
}
// TransformJobの為に、TransformAccessArrayを事前に生成しておきます
#region TRANSFORM_JOB
transformAccessArray = new UnityEngine.Jobs.TransformAccessArray(objectNum, 0);
for (int i = 0; i < objectNum; ++i)
{
transformAccessArray.Add(transformArray[i]);
}
#endregion TRANSFORM_JOB
// 座標計算等を並行処理させるために、事前に計算用のワークを確保しておきます
#region ARRAY_JOB
myStructNativeArray = new Unity.Collections.NativeArray <MyStruct>(objectNum, Unity.Collections.Allocator.Persistent);
#endregion ARRAY_JOB
}
public override void Execute()
{
// Re-initialisation of variables
ExecuteMethod.OnceInUpdate("SquadChildFSM.UpdateLandmineList", null, null);
Vector3 finalMovement = Vector3.zero; // finalMovement: The final movement in which will be used for that current frame
// if: There is no landmine, return the squad child to idle
if (SquadChildFSM.ListLandmine.Count == 0)
{
m_scFSM.Advance(SCState.Idle);
return;
}
// vectorApart: The distance between the current squad child cells and the current enemy child cells
Vector3 smallestVectorApart = Vector3.one * 3f;
Vector3 currentVectorApart;
// for: Check every landmine and determines the closest landmine to avoid
for (int i = 0; i < SquadChildFSM.ListLandmine.Count; i++)
{
currentVectorApart = m_scFSM.transform.position - SquadChildFSM.ListLandmine[i].transform.position;
// if: The current distance between the enemy and child cells is smaller than the current smallest
// then use this new vector as the smallest
if (currentVectorApart.magnitude < smallestVectorApart.magnitude)
{
smallestVectorApart = currentVectorApart;
}
}
// finalMovement: The final vector to travel to avoid other cells
finalMovement = smallestVectorApart.normalized * (1f - smallestVectorApart.magnitude / 3f);
//Debug.Log(m_scFSM.gameObject.name + "::Rigibody->velocity(): " + m_scFSM.RigidBody.velocity + ", finalMovment: " + finalMovement);
m_scFSM.RigidBody.AddForce(finalMovement * 10.0f);
m_scFSM.RigidBody.velocity = Vector3.ClampMagnitude(m_scFSM.RigidBody.velocity, finalMovement.magnitude * 0.5f);
}
/// <summary>
/// Initializes a new instance of the <see cref="DelegateCommand"/> class.
/// </summary>
/// <param name="exec">The execute method</param>
/// <param name="canExecutePredicate">Predicate Function with object parameter</param>
public DelegateCommand(ExecuteMethod exec, Func <object, bool> canExecutePredicate)
: this(exec)
{
canExecute = canExecutePredicate;
}
/// <summary>
/// Initializes a new instance of the <see cref="DelegateCommand"/> class.
/// </summary>
/// <param name="exec">The execute method</param>
public DelegateCommand(ExecuteMethod exec)
{
executeMethod = exec;
}
static void Main(string[] args)
{
ExecuteMethod timer = new ExecuteMethod(Message);
timer(5);
}
/// <summary>
/// Construtor padrão.
/// </summary>
/// <param name="exec"></param>
/// <param name="cmeth"></param>
public DelegateCommand(ExecuteMethod exec)
{
_meth = exec;
}
protected internal ExecuteCommand(ExecuteMethod method)
{
this.method = method ?? (x => { });
this.canExecuteFunc = x => method != null;
}
/// <summary>
/// Returns true if the specified execute method option has been enabled.
/// </summary>
public virtual bool IsExecuteMethodSelected(ExecuteMethod method)
{
return(method == (executeMethods & method));
}
private void Execute(ExecuteMethod executeMethod)
{
if (IsExecuteMethodSelected(executeMethod))
{
Execute();
}
}
// メニューで実行モードが変更された
public void OnChangedSelection(int val)
{
executeMethod = (ExecuteMethod)val;
}
public override void Execute()
{
targetNutrients = m_scFSM.GetNearestResource();
// if: The target nutrient is too close to the wall, disable the target
if (targetNutrients != null)
{
if (Mathf.Abs(targetNutrients.transform.position.x) >= 4f)
{
targetNutrients = null;
}
}
// Seperation Factor
// vSeperationVector: The final vector used to space away from all the other nearby cells
Vector3 vSeperationVector = Vector3.zero;
Collider2D[] array_nearbyCollider = Physics2D.OverlapCircleAll(m_scFSM.transform.position, 0.5f, Constants.s_onlySquadChildLayer);
if (array_nearbyCollider.Length > 0)
{
for (int i = 0; i < array_nearbyCollider.Length; i++)
{
// if: The current gameObject is itself
if (array_nearbyCollider[i] == m_scFSM.gameObject)
{
continue;
}
// vDirectionVector: The vector that the current squad child should be travelling in to space away from the current neighbour
Vector3 vDirectionVector = (m_scFSM.transform.position - array_nearbyCollider[i].transform.position);
// if: Somehow this is triggered, which is very often...
if (vDirectionVector.magnitude > 0)
{
vSeperationVector += vDirectionVector.normalized / vDirectionVector.sqrMagnitude;
}
}
// Average the the final vector to use for spacing away
vSeperationVector = vSeperationVector / array_nearbyCollider.Length;
vSeperationVector = Vector3.ClampMagnitude(vSeperationVector, 7f);
}
// Attraction Factor
ExecuteMethod.OnceInUpdate("SC_FindResourceState.RecalculateCenter", null, null);
Vector3 vAttractionVector = vCenterPosition - m_scFSM.transform.position;
vAttractionVector *= 10f;
// Final Velocity Vector
// toTargetVector: The vector between the target nutrients and the current squad child cells
Vector3 toTargetVector;
// if: There is no target nutrient, the find nutrients group will idle infront of squad group
if (targetNutrients == null)
{
toTargetVector = PlayerSquadFSM.Instance.transform.position + new Vector3(0f, 2f, 0f) - m_scFSM.transform.position;
}
else
{
toTargetVector = targetNutrients.transform.position - m_scFSM.transform.position;
}
toTargetVector *= 10f;
if (targetNutrients != null)
{
SquadChildFSM.Circle(targetNutrients.transform.position);
}
//Debug.Log("toTargetVector: " + toTargetVector.magnitude + ", vSeperationVector: " + vSeperationVector.magnitude + ", vAttractionVector: " + vAttractionVector.magnitude);
// Apply vector to velocity
/* Quick Vector Summary:
* toTargetVector -> The vector between the nutrients and the 'FindResource' group
* vSeperationVector -> The personal space vector
* vAttractionVector -> The 'stay as a group' vector
*/
m_scFSM.RigidBody.AddForce(toTargetVector + vSeperationVector + vAttractionVector * Time.deltaTime * 100f, ForceMode2D.Force);
m_scFSM.RigidBody.velocity = Vector3.ClampMagnitude(m_scFSM.RigidBody.velocity, 3f);
// if: The distance between the two bodies is less than a certain distance
if (targetNutrients != null)
{
if (Vector3.Distance(targetNutrients.transform.position, m_scFSM.transform.position) < 0.5f)
{
// if: The current squad child is added to the nutrients
if (targetNutrients.AddSquadChildCount())
{
m_scFSM.Advance(SCState.Dead);
targetNutrients = null;
}
}
}
}
public void CommandExecute(ProxyDbCommand command, TimeSpan duration, ExecuteMethod method, List<QueryExecutionPlan> executionPlan, object result = null)
{
_profileOutput.CommandExecute(command, duration, method, executionPlan, result);
}
protected void Execute(ExecuteMethod executeMethod)
{
if (IsExecuteMethodSelected(executeMethod))
{
Execute();
}
}
public override void Exit()
{
ExecuteMethod.OnceInUpdate("SquadChildFSM.CalculateDefenceSheildOffset", null, null);
}
public MessageControl(ExecuteMethod method)
{
this.a_restService = method.ToString();
this.a_restUrl = string.Format("{0}:{1}/{2}/", ConfigurationInfo.RestHost, ConfigurationInfo.RestPort, this.a_restService);
}
public RemoveCommand(ExecuteMethod <T> executeRemove, CanExecuteMethod <T> canExecuteRemove)
{
this.executeRemove = executeRemove;
this.canExecuteRemove = canExecuteRemove;
}
public void CommandExecute(ProxyDbCommand command, TimeSpan duration, ExecuteMethod method, List<QueryExecutionPlan> executionPlan, object result)
{
var commandMessage = new Van.Parys.Data.Common.CommandMessage(command.CommandText, duration, method.ToString(), command.ProxyDbConnection.Guid) {QueryExecutionPlans = executionPlan, NonReaderResult = result};
Debug.WriteLine(commandMessage.ToString());
}
protected internal ExecuteCommand(ExecuteMethod method, Func<object, bool> canExecuteFunc)
: this(method)
{
this.canExecuteFunc = canExecuteFunc ?? (x => true);
}
public void Execute(TParameter parameter)
{
ExecuteMethod?.Invoke(parameter);
}
/// <summary>
/// Returns true if the specified execute method option has been enabled.
/// </summary>
public virtual bool IsExecuteMethodSelected(ExecuteMethod method)
{
return method == (executeMethods & method);
}
internal static void TestExecuteSourcesNoInput(string source, string baseline, string testname, ExecuteMethod method)
{
TestExecuteSourcesNoInput(new string[] { source }, baseline, testname, method);
}
