public override void SetField(Thread thread, TargetStructObject instance,
TargetFieldInfo field, TargetObject value)
{
if (field.IsStatic)
{
if (instance != null)
{
throw new InvalidOperationException();
}
SetStaticField(thread, field, value);
}
else
{
if (instance == null)
{
throw new InvalidOperationException();
}
thread.ThreadServant.DoTargetAccess(
delegate(TargetMemoryAccess target) {
SetInstanceField(target, instance, field, value);
return(null);
});
}
}
void Start()
{
//Setup defaults
orignialAttackRange = attackRange;
orignialAttackDamage = attackDamage;
orignialAgroRange = agroRange;
orignialAttackCooldown = attackCooldown;
orignialMiningRate = miningRate;
orignialMineTime = mineTime;
orignialMineMaxInv = mineMaxInv;
orignialRepairTime = repairTime;
orignialRepairAmount = repairAmount;
baseModel.SetActive(true);
minerModel.SetActive(false);
boostModel.SetActive(false);
fighterModel.SetActive(false);
animator = baseModel.GetComponent <Animator>();
//Setup Components
agent = GetComponent <NavMeshAgent>();
objID = GetComponent <ObjectID>();
objID.objID = ObjectID.OBJECTID.UNIT;
interactLayer = GameObject.FindGameObjectWithTag("MainCamera").GetComponent <PlayerController>().unitInteractLayers;
target = new TargetObject(Vector3.zero);
FindTC();
GM = GameObject.FindGameObjectWithTag("GameManager").GetComponent <GameManager>();
lr = GetComponent <LineRenderer>();
lr.enabled = false;
}
/*
* These will be called by base class
*/
protected override BaseDMeshSourceOp edit_op_factory(TargetObject o)
{
return(new RemeshOp()
{
MeshSource = o.MeshSourceOp
});
}
public IReadOnlyList <KeyValuePair <ClrObject, ClrObject> > GetKeyValuePair()
{
// bucketsObject is an array of 'bucket' struct
var bucketsObject = TargetObject.ReadObjectField("buckets");
var elementType = bucketsObject.Type.ComponentType;
var bucketKeyField = elementType.GetFieldByName("key");
var bucketValField = elementType.GetFieldByName("val");
var bucketsLength = bucketsObject.AsArray().Length;
var result = new List <KeyValuePair <ClrObject, ClrObject> >();
for (int bucketIndex = 0; bucketIndex < bucketsLength; bucketIndex++)
{
//var arrayProxy = new ArrayProxy(Context, bucketsObject);
// TODO move to ArrayProxy
var elementAddress = bucketsObject.Type.GetArrayElementAddress(bucketsObject.Address, bucketIndex);
var keyObject = bucketKeyField.ReadObject(elementAddress, true);
if (!keyObject.IsNull)
{
var valObject = bucketValField.ReadObject(elementAddress, true);
var kvp = new KeyValuePair <ClrObject, ClrObject>(keyObject, valObject);
result.Add(kvp);
}
}
return(result);
}
public void FormatVariable(StackFrame frame, TargetVariable variable)
{
TargetObject obj = null;
Append("{0} = ", variable.Name);
if (!variable.IsAlive(frame.TargetAddress))
{
Append("<optimized out>");
return;
}
try {
obj = variable.GetObject(frame);
if (obj != null)
{
Format(frame.Thread, obj);
}
else
{
Append("<cannot display object>");
}
} catch {
Append("<cannot display object>");
}
}
public bool Click(out TargetObject target)
{
target = null;
for (int i = 0; i < targetObjectManager.targets.Count; i++)
{
float pos = targetObjectManager.targets[i].GetPos();
if (pos >= areaLowerLimit)
{
if (pos < areaUpperLimit)
{
target = targetObjectManager.targets[i];
if (target.id == id && target.GetIsClicked() != true)
{
target.SetIsClicked(true);
ClickEffect obj = objectPool.GetItem(clickEffect, null).GetComponent <ClickEffect>();
obj.transform.localPosition = Vector3.zero;
obj.Play(target.transform);
return(true);
}
}
else
{
return(false);
}
}
}
return(false);
}
/// <summary>
/// Create a statementLine using the given member data.
/// </summary>
/// <returns>Returns the generated CodeStatement.</returns>
public CodeExpression CreateExpression()
{
return(Parameters != null
? new CodeDelegateInvokeExpression(TargetObject.CreateExpression(),
Parameters.Select(p => p.CreateExpression()).ToArray())
: new CodeDelegateInvokeExpression(TargetObject.CreateExpression()));
}
protected override void GenerateInner(CodeGenerator generator)
{
if (TargetObject.Precedence > PrecedenceGroup.Primary)
{
generator.Write(TokenType.Punctuation, '(');
}
TargetObject.Generate(generator);
if (TargetObject.Precedence > PrecedenceGroup.Primary)
{
generator.Write(TokenType.Punctuation, ')');
}
generator.Write(TokenType.Punctuation, '[');
bool first = true;
foreach (CodeExpression index in Indices)
{
if (first)
{
first = false;
}
else
{
generator.Write(TokenType.Punctuation, ',');
generator.Write(TokenType.Space, ' ');
}
index.Generate(generator);
}
generator.Write(TokenType.Punctuation, ']');
}
public aiDebug(TargetObject _t, bool _s, bool _i, AttackState _a)
{
target = _t;
stuck = _s;
idle = _i;
attackState = _a;
}
internal override void SetObject(TargetMemoryAccess target, TargetLocation location,
TargetObject obj)
{
TargetLocation flag_loc = location.GetLocationAtOffset (ElementType.Size);
byte[] buffer = new byte [1];
if (obj is TargetNullObject) {
buffer [0] = 0;
flag_loc.WriteBuffer (target, buffer);
return;
}
MonoNullableObject nobj = obj as MonoNullableObject;
if (nobj != null) {
if (!nobj.HasValue (target)) {
buffer [0] = 0;
flag_loc.WriteBuffer (target, buffer);
return;
} else {
obj = nobj.GetValue (target);
}
}
buffer [0] = 1;
flag_loc.WriteBuffer (target, buffer);
ElementType.SetObject (target, location, obj);
}
protected override void OnTargetChanged()
{
if (TargetObject != null && TargetProperty != null)
{
var property = TargetObject.GetType().GetProperty(TargetProperty);
if (property == null)
{
throw new Exception(string.Format("Property {0} on target type {1} not found",
TargetProperty, TargetObject.GetType().FullName));
}
if (property.PropertyType != typeof(Rectangle))
{
throw new Exception(string.Format("Expecting TargetProperty {0} on target type {1} to be of type System.Drawing.Rectangle, but found it to be of type {2}",
TargetProperty, TargetObject.GetType().FullName, property.PropertyType.FullName));
}
var setter = property.GetSetMethod();
if (setter == null)
{
throw new Exception(string.Format("Expecting TargetProperty {0} on target type {1} to be settable, but it is not.",
TargetProperty, TargetObject.GetType().FullName));
}
var argument = Expression.Parameter(property.PropertyType, property.Name);
var instance = Expression.Parameter(typeof(Shape), "this");
var typed = Expression.Convert(instance, TargetObject.GetType());
var call = Expression.Call(typed, setter, argument);
this._lambda = Expression.Lambda <System.Action <Shape, Rectangle> >(call, instance, argument).Compile();
Debug.WriteLine("Lambda created");
}
else
{
this._lambda = null;
}
}
public override string ToString()
{
return(string.Format("NodeTranslatorBound {0} {1} for {2}",
Priority,
TargetObject.GetType().ExcName(),
Method.GetParameters()[1].ParameterType.ExcName()));
}
public void ExecuteAction(TargetObject target)
{
Random ran = new Random();
int damageRolls = ran.Next(4) + ran.Next(4) + ran.Next(4) + 3;
target.TargetCharacter.HitpointsCurrent -= damageRolls + 3;
}
public static void WizardRandomTarget(ICECreatureControl _control, TargetObject _target)
{
string _new_target_name = (_target.Type.ToString() + "_" + _control.transform.name).ToUpper();
GameObject _new_target_object = GameObject.Find(_new_target_name);
if (_new_target_object == null)
{
_new_target_object = new GameObject();
_new_target_object.transform.position = _control.transform.position;
_new_target_object.name = _new_target_name;
_new_target_object.AddComponent <ICECreatureLocation>();
if (ICECreatureRegister.Instance != null)
{
_new_target_object.transform.parent = ICECreatureRegister.Instance.HierarchyManagement.GetHierarchyGroupTransform(EntityClassType.Location);
}
}
_target.OverrideTargetGameObject(_new_target_object);
_target.Move.Enabled = true;
_target.Move.Foldout = true;
_target.Move.RandomRange = 100; //Random.Range( Init.WIZARD_RANDOM_RANGE_MIN, Init.WIZARD_RANDOM_RANGE_MAX );
_target.Move.UseUpdateOffsetOnActivateTarget = true;
_target.Move.UseUpdateOffsetOnMovePositionReached = true;
_target.Move.StoppingDistance = 2;
_target.Move.IgnoreLevelDifference = true;
if (ICECreatureRegister.Instance != null)
{
ICECreatureRegister.Instance.AddReference(_target.TargetGameObject);
}
}
public ActionResult Search(string phone)
{
DataQuery query = new DataQuery();
var listTarget = new List <TargetObject>();
var splitStr = phone.Split(',');
foreach (var item in splitStr)
{
var tb = new DataTable();
tb = query.GetTargetByPhone(item);
if (tb != null && tb.Rows.Count > 0)
{
try
{
var tempTarget = new TargetObject();
tempTarget.MSISDN = tb.Rows[0]["MSISDN"].ToString();
tempTarget.Route = tb.Rows[0]["Recipient"].ToString();
listTarget.Add(tempTarget);
}
catch
{
}
}
}
return(View(listTarget));
}
protected override void LoadContent()
{
base.LoadContent();
_systemReady = true;
try
{
FromInternal("{error}", "Error.derpyeyes");
FromInternal("{notex}", "Error.notexture");
FromInternal("{achievement}", "Data.achievements");
FromInternal("{bits}", "UI.bitcollection");
FromInternal("{load}", "Loading.loadingscreen_filler");
var Effect = new Objects.Graphics.BasicEffectObject("{basic_effect}");
var smallFont = new FontObject("{smallfont}", @"fonts\celestia_redux");
_fonts["{smallfont}"] = smallFont;
var largeFont = new FontObject("{largefont}", @"fonts\celestia_redux_large");
_fonts["{largefont}"] = largeFont;
_frameCapture = new TargetObject("{screen}", GraphicsDevice, EngineGlobals.Settings.WindowWidth, EngineGlobals.Settings.WindowHeight);
_empty = CreatePixelTexture("{empty}", Color.Transparent);
_singleWhite = CreatePixelTexture("{single}");
}
catch (System.Exception ex)
{
EquestriEngine.ErrorMessage = ex.Message;
}
LoadTextures();
LoadFonts();
LoadEffects();
LoadSkeletons();
}
//********初期化********//
public virtual void Init(AdvGraphicLayer layer, AdvGraphicInfo graphic)
{
this.layer = layer;
this.rectTransform = this.transform as RectTransform;
this.rectTransform.SetStretch();
if (graphic.RenderTextureSetting.EnableRenderTexture)
{
InitRenderTextureImage(graphic);
}
else
{
GameObject child = this.transform.AddChildGameObject(graphic.Key);
this.TargetObject = this.RenderObject = child.AddComponent(graphic.GetComponentType()) as AdvGraphicBase;
this.TargetObject.Init(this);
}
//リップシンクのキャラクターラベルを設定
LipSynchBase lipSync = TargetObject.GetComponentInChildren <LipSynchBase>();
if (lipSync != null)
{
lipSync.CharacterLabel = this.gameObject.name;
lipSync.OnCheckTextLipSync.AddListener(
(x) =>
{
x.EnableTextLipSync = (x.CharacterLabel == Engine.Page.CharacterLabel && Engine.Page.IsSendChar);
});
}
this.FadeTimer = this.gameObject.AddComponent <Timer>();
this.effectColor = this.GetComponentCreateIfMissing <AdvEffectColor>();
this.effectColor.OnValueChanged.AddListener(RenderObject.OnEffectColorsChange);
}
/// <summary>
/// Loads and show's the view
/// </summary>
/// <param name="path">Path.</param>
protected void LoadAndShowView(string path)
{
if (string.IsNullOrEmpty(path))
{
SimpleLogger.LogError(this, "Attempting to load view at invalid path.");
return;
}
GameObject prefab = Resources.Load <GameObject>(path);
if (prefab == null)
{
SimpleLogger.LogError(this, "Attempting to load view at invalid path.");
return;
}
view = GameObject.Instantiate(prefab).GetComponent <BaseGameStateView>();
if (view == null)
{
SimpleLogger.LogError(this, "View is missing the required component.");
return;
}
TargetObject.ShowView(view);
}
protected async override Task <Action <AsyncCodeActivityContext> > ExecuteAsync(AsyncCodeActivityContext context, CancellationToken cancellationToken)
{
IInvoker invoker = JavaScope.GetJavaInvoker(context);
var fieldName = FieldName.Get(context) ?? throw new ArgumentNullException(Resources.FieldName);
var javaObject = TargetObject.Get(context);
var className = TargetType.Get(context);
if (javaObject == null && className == null)
{
throw new InvalidOperationException(Resources.InvokationObjectException);
}
JavaObject instance;
try
{
instance = await invoker.InvokeGetField(javaObject, fieldName, className, cancellationToken);
}
catch (Exception e)
{
Trace.TraceError($"Could not get java field: {e}");
throw new InvalidOperationException(Resources.GetFieldException, e);
}
return(asyncCodeActivityContext =>
{
Result.Set(asyncCodeActivityContext, instance);
});
}
void DrawSub(AdvGraphicInfo graphic, float fadeTime)
{
TargetObject.name = graphic.File.FileName;
/* if (LastResource != graphic)
* {
* TargetObject.ChangeResourceOnDraw(graphic, fadeTime);
* }*/
TargetObject.ChangeResourceOnDraw(graphic, fadeTime);
if (RenderObject != TargetObject)
{
//テクスチャ書き込みをしている
RenderObject.ChangeResourceOnDraw(graphic, fadeTime);
if (graphic.IsUguiComponentType)
{
//UGUI系は、描画するImageにスケール値を適用
RenderObject.Scale(graphic);
}
}
else
{
TargetObject.Scale(graphic);
}
RenderObject.Alignment(Layer.SettingData.Alignment, graphic);
RenderObject.Flip(Layer.SettingData.FlipX, Layer.SettingData.FlipY);
this.LastResource = graphic;
}
public virtual void DoMoveComplete(GameObject _sender, TargetObject _target)
{
if (OnMoveComplete != null)
{
OnMoveComplete(_sender, _target);
}
}
public void Refresh()
{
ResultList.Clear();
var rl = TargetObject.GetResult();
if (rl == null)
{
return;
}
var l = new List <IInstrument>();
foreach (var r in rl)
{
l.Add(Instrument.AllInstrumentList.FirstOrDefault(v => v.Ticker == r.Ticker));
}
l.ForEach(v => ResultList.Add(v));
CalculateList.Clear();
foreach (var kv in rl)
{
CalculateList.Add(new CalculateItem()
{
Name = kv.InstrumentName, Ticker = kv.Ticker, Value = kv.Value
});
}
}
private bool GetBool(string condition)
{
Type classType = TargetObject.GetType();
SerializedProperty property = SerializedObject.FindProperty(condition);
if (property != null)
{
return(GetBool(property));
}
MethodInfo method = classType.GetMethod(condition, findValueFlags);
if (method != null)
{
object methodValue = method.Invoke(TargetObject, null);
return(methodValue.GetBool());
}
FieldInfo field = classType.GetField(condition, findValueFlags);
if (field != null)
{
object fieldValue = field.GetValue(TargetObject);
return(fieldValue.GetBool());
}
Debug.LogError($"Your condition in InspectorHideAttribute is invalid! Class: {classType}");
return(true);
}
private IEnumerator DoLerpTransform(float lerpTime, TargetObject oldTarget, TargetObject newTarget)
{
if (oldTarget != null)
{
oldTarget.SetVisible(true);
transform.SetLayerRecursive(OverlayLayer);
}
Vector3 startPosition = transform.localPosition;
Vector3 startScale = transform.localScale;
Quaternion startRotation = transform.localRotation;
float time = 0;
while (time <= lerpTime)
{
time += Time.deltaTime;
float t = time / lerpTime;
transform.localPosition = Vector3.Lerp(startPosition, _wantedPosition, t);
transform.localRotation = Quaternion.Slerp(startRotation, _wantedRotation, t);
transform.localScale = Vector3.Lerp(startScale, _wantedScale, t);
yield return(null);
}
if (newTarget != null)
{
newTarget.SetVisible(false);
transform.SetLayerRecursive(DefaultLayer);
}
_lerpingCoroutine = null;
}
private void UpdateGuideLine()
{
//We set a line between the object and a possible target
if (_currentGuideLineTarget == null || !_currentGuideLineTarget.isActiveAndEnabled ||
_currentGuideLineTarget.Completed)
{
TargetObject target = TargetObject.GetActiveTarget(ModelName);
if (_guideLinePreview == null)
{
_guideLinePreview = Instantiate(_guideLinePrefab);
_guideLinePreview.transform.SetLayerRecursive(OverlayLayer);
}
if (target != null)
{
_guideLinePreview.gameObject.SetActive(true);
_guideLinePreview.Start = transform;
_guideLinePreview.End = target.transform;
}
else
{
_guideLinePreview.gameObject.SetActive(false);
}
_currentGuideLineTarget = target;
}
}
private void NoticeTarget(TargetObject target)
{
var idToAdd = target.uid;
//Make sure we havent seen the target before
foreach (var t in targetIDs)
{
if (t == idToAdd)
{
return;
}
}
lastKnownTargetPositions.Add(target.transform.position);
currentlyNoticedTargets.Add(target);
targetIDs.Add(idToAdd);
ChooseTarget();
//if we are not engaging in combat start now!
if (!engaging)
{
agent.StartEngaging();
engaging = true;
}
}
internal override void SetObject(TargetMemoryAccess target, TargetLocation location,
TargetObject obj)
{
TargetLocation flag_loc = location.GetLocationAtOffset(ElementType.Size);
byte[] buffer = new byte [1];
if (obj is TargetNullObject)
{
buffer [0] = 0;
flag_loc.WriteBuffer(target, buffer);
return;
}
MonoNullableObject nobj = obj as MonoNullableObject;
if (nobj != null)
{
if (!nobj.HasValue(target))
{
buffer [0] = 0;
flag_loc.WriteBuffer(target, buffer);
return;
}
else
{
obj = nobj.GetValue(target);
}
}
buffer [0] = 1;
flag_loc.WriteBuffer(target, buffer);
ElementType.SetObject(target, location, obj);
}
/// <inheritdoc/>
public async Task <bool> IsPreyHunted(int hunterId, int preyId)
{
var requestObject = new TargetObject()
{
HunterPersonId = hunterId,
PreyPersonId = preyId,
IsHunted = false
};
const string restUrl = "https://teststorageserver.azurewebsites.net/api/game/remove";
var uri = new Uri(restUrl);
var jsonContent = JsonConvert.SerializeObject(requestObject, new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore
});
var request = new HttpRequestMessage(HttpMethod.Post, uri)
{
Content = new StringContent(jsonContent, Encoding.UTF8, "application/json")
};
var response = await HttpClient.SendAsync(request);
if (!response.IsSuccessStatusCode)
{
var errorContent = await response.Content.ReadAsStringAsync();
throw new ManagerException((JsonConvert.DeserializeObject <BadRequestModel>(errorContent)).Message);
}
var responseContent = await response.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <bool>(responseContent));
}
/// <summary>
/// Draws the target influence settings.
/// </summary>
/// <param name="_control">Control.</param>
/// <param name="_target">Target.</param>
public static void DrawTargetInfluenceSettings(ICECreatureControl _control, TargetObject _target)
{
ICEEditorLayout.BeginHorizontal();
EditorGUI.BeginDisabledGroup(_target.Influences.Enabled == false);
_target.Influences.Foldout = ICEEditorLayout.Foldout(_target.Influences.Foldout, "Creature Influences", "", false);
EditorGUI.EndDisabledGroup();
GUILayout.FlexibleSpace();
InteractorRuleObject _rule = _target as InteractorRuleObject;
if (_rule != null)
{
_rule.OverrideInfluences = ICEEditorLayout.CheckButtonMiddle("OVERRIDE", "Overrides initial target influences", _rule.OverrideInfluences);
_rule.Influences.Enabled = _rule.OverrideInfluences;
if (!_rule.OverrideInfluences)
{
_rule.Influences.Foldout = false;
}
}
else
{
_target.Influences.Enabled = ICEEditorLayout.EnableButton("Enables/disables the influences", _target.Influences.Enabled);
}
ICEEditorLayout.EndHorizontal(Info.TARGET_INFLUENCES);
EditorGUI.BeginDisabledGroup(_target.Influences.Enabled == false);
CreatureObjectEditor.DrawInfluenceObject(_target.Influences, EditorHeaderType.FOLDOUT_CUSTOM, _control.Creature.Status.UseAdvanced, _control.Creature.Status.InitialDurabilityMax, Info.ENVIROMENT_COLLISION_INFLUENCES);
EditorGUI.EndDisabledGroup();
}
//文字列指定でのパターンチェンジ（キーフレームアニメーションに使う）
public virtual void ChangePattern(string pattern)
{
if (TargetObject != null)
{
TargetObject.ChangePattern(pattern);
}
}
/// <summary>
/// 指定されている<see cref="KecaknoahObject"/>を呼び出し、次の値を取得します。
/// </summary>
/// <returns>継続可能な場合はtrue、それ以外の場合はfalse。</returns>
public bool MoveNext()
{
var r = TargetObject.Call(this, IsResuming ? null : Arguments.ToArray());
Current = r.ReturningObject;
return(IsResuming = r.CanResume);
}
public SelectTransformerTests()
{
theMapping = DocumentMapping.For<User>();
theTarget = new TargetObject(typeof(invoking_query_with_select_Tests.User2));
theTarget.StartBinding(ReflectionHelper.GetProperty<User>(x => x.FirstName)).Members.Add(ReflectionHelper.GetProperty<User2>(x => x.First));
theTarget.StartBinding(ReflectionHelper.GetProperty<User>(x => x.LastName)).Members.Add(ReflectionHelper.GetProperty<User2>(x => x.Last));
theSelector = new SelectTransformer<User2>(theMapping, theTarget);
}
public override void SetField(Thread thread, TargetStructObject instance,
TargetFieldInfo field, TargetObject value)
{
TargetLocation field_loc = instance.Location.GetLocationAtOffset (field.Offset);
if (field.Type.IsByRef)
field_loc = field_loc.GetDereferencedLocation ();
NativeFieldInfo nfield = (NativeFieldInfo) field;
if (!field.Type.IsByRef && nfield.IsBitfield)
field_loc = new BitfieldTargetLocation (
field_loc, nfield.BitOffset, nfield.BitSize);
// field.Type.SetObject (field_loc, value);
throw new NotImplementedException ();
}
internal override void SetElement(TargetMemoryAccess target, int[] indices,
TargetObject obj)
{
int offset = GetArrayOffset (target, indices);
TargetBlob blob;
TargetLocation dynamic_location;
try {
blob = Location.ReadMemory (target, Type.Size);
GetDynamicSize (target, blob, Location, out dynamic_location);
} catch (TargetException ex) {
throw new LocationInvalidException (ex);
}
TargetLocation new_loc = dynamic_location.GetLocationAtOffset (offset);
Type.ElementType.SetObject (target, new_loc, obj);
}
public override TargetObjectObject CreateBoxedObject(Thread thread, TargetObject value)
{
throw new NotSupportedException ();
}
internal void SetInstanceField(TargetMemoryAccess target,
TargetStructObject instance,
TargetFieldInfo field, TargetObject obj)
{
GetFields (target);
int offset = field_offsets [field.Position];
TargetType type = field_types [field.Position];
if (!Type.IsByRef)
offset -= 2 * target.TargetMemoryInfo.TargetAddressSize;
TargetLocation field_loc = instance.Location.GetLocationAtOffset (offset);
if (type.IsByRef)
field_loc = field_loc.GetDereferencedLocation ();
type.SetObject (target, field_loc, obj);
}
public override void SetField(Thread thread, TargetStructObject instance,
TargetFieldInfo field, TargetObject value)
{
if (field.IsStatic) {
if (instance != null)
throw new InvalidOperationException ();
SetStaticField (thread, field, value);
} else {
if (instance == null)
throw new InvalidOperationException ();
thread.ThreadServant.DoTargetAccess (
delegate (TargetMemoryAccess target) {
SetInstanceField (target, instance, field, value);
return null;
});
}
}
internal void SetStaticField(TargetMemoryAccess target, TargetFieldInfo field,
TargetAddress data_address, TargetObject obj)
{
GetFields (target);
int offset = field_offsets [field.Position];
TargetType type = field_types [field.Position];
TargetLocation location = new AbsoluteTargetLocation (data_address);
TargetLocation field_loc = location.GetLocationAtOffset (offset);
if (type.IsByRef)
field_loc = field_loc.GetDereferencedLocation ();
type.SetObject (target, field_loc, obj);
}
internal void SetStaticField(Thread thread, TargetFieldInfo field,
TargetObject obj)
{
if (!thread.CurrentFrame.Language.IsManaged)
throw new TargetException (TargetError.InvalidContext);
TargetAddress data_address = thread.CallMethod (
SymbolFile.MonoLanguage.MonoDebuggerInfo.ClassGetStaticFieldData,
KlassAddress, 0);
thread.ThreadServant.DoTargetAccess (
delegate (TargetMemoryAccess target) {
SetStaticField (target, field, data_address, obj);
return null;
});
}
internal override void SetElement(TargetMemoryAccess target, int[] indices,
TargetObject obj)
{
throw new NotSupportedException ();
}
// Use this for initialization
void Start()
{
if (target == null)
target = FindObjectOfType<TargetObject>();
}
public override void SetObject(StackFrame frame, TargetObject obj)
{
frame.Thread.ThreadServant.DoTargetAccess (
delegate (TargetMemoryAccess target) {
SetObject (frame, target, obj);
return null;
});
}
internal void SetObject(StackFrame frame, TargetMemoryAccess target,
TargetObject obj)
{
TargetLocation location = GetLocation (frame, target);
if (location == null)
throw new LocationInvalidException ();
type.SetObject (target, location, (TargetObject) obj);
}
internal void SetField(TargetMemoryAccess target, TargetLocation location,
NativeFieldInfo field, TargetObject obj)
{
TargetLocation field_loc = location.GetLocationAtOffset (field.Offset);
if (field.Type.IsByRef)
field_loc = field_loc.GetDereferencedLocation ();
if (!field.Type.IsByRef && field.IsBitfield)
field_loc = new BitfieldTargetLocation (
field_loc, field.BitOffset, field.BitSize);
// field.Type.SetObject (field_loc, obj);
throw new NotImplementedException ();
}
public override void ShowGui(RuleData ruleData)
{
GUILayout.Label("deactivate", RuleGUI.ruleLabelStyle);
int index = targetObjectDropDown.Draw();
if (index > -1)
{
TargetObj = (TargetObject)index;
ChangeParameter("TargetObj", ruleData.parameters, TargetObj);
}
if (TargetObj == TargetObject.ACTOR)
{
int resultIndex = actorDropDown.Draw();
if (resultIndex > -1)
{
int resultId = generator.Gui.GetActorDataByLabel(actorDropDown.Content[resultIndex].text).id;
(ruleData as ReactionData).actorId = resultId;
ChangeParameter("ObjectToDeactivate", (ruleData as ReactionData).parameters, resultId);
if (resultId != Reactor.Id)
generator.ChangeActor(this, resultId);
ObjectToDeactivate = Reactor;
}
}
GUILayout.Label("after", RuleGUI.ruleLabelStyle);
Timeout = RuleGUI.ShowParameter(Timeout);
ChangeParameter("Timeout", (ruleData as ReactionData).parameters, Timeout);
GUILayout.Label("seconds", RuleGUI.ruleLabelStyle);
}
public static void ProcessFunctionToObjects(ProcessingFunction func, string name, TargetObject to)
{
if (IsValidArgs(name) == false)
return;
List<GameObject> list = poolDic[name].objectList;
int count = 0;
int startIndex = 0;
if (to == TargetObject.ACTIVE_ONLY)
{
count = poolDic[name].ActiveCount;
startIndex = poolDic[name].InActiveCount;
}
else if (to == TargetObject.INACTIVE_ONLY)
count = poolDic[name].InActiveCount;
else
count = poolDic[name].ActiveCount + poolDic[name].InActiveCount;
for (int i = startIndex; i < startIndex + count; ++i)
{
func(list[i]);
}
}
