private void PlayerPropertyChange(object sender, PropertyChangeEventArgs e)
{
if (e.PropertyName != nameof(Player.Position))
{
return;
}
var newPos = (Point)e.NewValue;
var oldPos = (Point)e.OldValue;
if (propertyChangedRelevant)
{
PlayerAction action;
if (sender is Player senderPlayer)
{
action = new PlayerAction(senderPlayer, ActionType.Moved, new Point(newPos.X - oldPos.X, newPos.Y - oldPos.Y));
}
else
{
action = new PlayerAction(player, ActionType.Moved, new Point(newPos.X - oldPos.X, newPos.Y - oldPos.Y));
}
action.Order = NextOrder;
actions.Push(action);
player.Role.SetUsedActionPoints(actions.Count);
}
}
private void OnSourcePropertyChanged(object o, PropertyChangeEventArgs args)
{
switch (args.PropertyName)
{
case "Nereid.SourceContents":
ThreadAssist.ProxyToMain(delegate {
UpdateSourceContents(previous_source);
});
break;
case "FilterQuery":
var source = ServiceManager.SourceManager.ActiveSource;
var search_entry = source.Properties.Get <SearchEntry> ("Nereid.SearchEntry") ?? view_container.SearchEntry;
if (!search_entry.HasFocus)
{
ThreadAssist.ProxyToMain(delegate {
view_container.SearchEntry.Ready = false;
view_container.SearchEntry.Query = source.FilterQuery;
view_container.SearchEntry.Ready = true;
});
}
break;
case "Nereid.SimpleUI":
SetSimple(ServiceManager.SourceManager.ActiveSource.Properties.Get <bool> ("Nereid.SimpleUI"));
break;
}
}
/// <summary>
/// Updates available items when those change on the property.
/// </summary>
/// <param name="e">Property change details.</param>
/// <param name="token">Cancellation token.</param>
protected virtual async Task OnPropertyChangeAsync(PropertyChangeEventArgs e, CancellationToken token)
{
if (e.Change.IncludesItems() && Equals(Row, e.Row))
{
await GetAvailableItems(null, token);
}
}
private void OnPropertyChanged(object o, PropertyChangeEventArgs args)
{
if (args.PropertyName == "Icon.Name")
{
UpdateIcon();
}
}
/// <summary>
/// Updates the visibility and the Required flag of the additional properties
/// based on the currently selected operator. Clears their values, if invisible.
/// This method is triggered whenever the current operator changes.
/// </summary>
/// <param name="sender">The event sender.</param>
/// <param name="e">Property change event arguments.</param>
protected void OnValueChanged(object sender, PropertyChangeEventArgs e)
{
if (!e.Change.IncludesValue() && !e.Change.IncludesVisible() || additionalProperty == null)
{
return;
}
int depCnt = 0;
if (!IsNull())
{
int.TryParse("" + Value[AttributeAddlProps], out depCnt);
}
additionalProperty.Visible = Visible && depCnt > 0;
additionalProperty.Required = additionalProperty.Visible;
if (!additionalProperty.Visible)
{
additionalProperty.SetValue(null);
}
if (additionalProperty2 != null)
{
additionalProperty2.Visible = Visible && depCnt > 1;
additionalProperty2.Required = additionalProperty2.Visible;
if (!additionalProperty2.Visible)
{
additionalProperty2.SetValue(null);
}
}
}
// Reflect messages from Documents to our listeners
void Document_PropertyChange(object sender, PropertyChangeEventArgs args)
{
if (PropertyChange != null)
{
PropertyChange(sender, args);
}
}
/// <summary>
/// Overrides handling of the property change to always update the control
/// and also trigger stop editing if the control actually changed the property value.
/// </summary>
/// <param name="sender">Event sender.</param>
/// <param name="e">Property change event arguments.</param>
protected override void OnPropertyChange(object sender, PropertyChangeEventArgs e)
{
// prevent posting value if property value got changed
// outside of control (e.g. via cascading selection)
if (e.Change == PropertyChange.Value)
{
PostedValue = null;
}
// change base behavior to always update the control
// e.g. to refresh a required dropdown list
bool b = PreventElementUpdate;
PreventElementUpdate = false;
base.OnPropertyChange(sender, e);
PreventElementUpdate = b;
// stop the editing (and hence trigger the editing end event),
// if the posted value actually changed the property value
if (property == sender && PreventElementUpdate &&
e.Change == PropertyChange.Value && !Equals(e.OldValue, e.NewValue))
{
property.Editing = false;
}
}
private void HandleSelectionChanged(object sender, PropertyEventArgs args_)
{
PropertyChangeEventArgs args = args_ as PropertyChangeEventArgs;
Rectangle invalid = Rectangle.Empty;
if (args != null)
{
if (args.NewValue is Strokes)
{
invalid = ((Strokes)args.NewValue).GetBoundingBox();
if (args.OldValue is Strokes)
{
invalid = Rectangle.Union(invalid, ((Strokes)args.OldValue).GetBoundingBox());
}
}
else if (args.OldValue is Strokes)
{
invalid = ((Strokes)args.OldValue).GetBoundingBox();
}
}
// Inflate the invalid region by the width of the border drawn around selected strokes,
// sine Strokes.GetBoundingBox only accounts for the width of the strokes' natural DrawingAttributes.
invalid.Inflate(SELECTED_BORDER_WIDTH__HIMETRIC, SELECTED_BORDER_WIDTH__HIMETRIC);
this.InvalidateInkSpaceRectangle(invalid);
}
public void LevelHandler(object sender, PropertyChangeEventArgs args)
{
if (node != null)
{
if (level == 0)
{
level = (int)node.GetProperty("level");
}
if (level != (int)node.GetProperty("level"))
{
if (level != 0 && timeDelay < Time.time)
{
if (AtavismSettings.Instance.LevelUpPrefab != null)
{
go = (GameObject)Instantiate(AtavismSettings.Instance.LevelUpPrefab, transform.position, transform.rotation, transform);
}
}
level = (int)node.GetProperty("level");
timeDelay = Time.time + 1f;
}
}
if (go != null)
{
Destroy(go, AtavismSettings.Instance.LevelUpPrefabDuration);
}
}
public void ScaleHandler(object sender, PropertyChangeEventArgs args)
{
AtavismLogger.LogDebugMessage("Got scale");
Vector3 scaleObj = (Vector3)GetComponent <AtavismNode>().GetProperty("scale");
gameObject.transform.localScale = scaleObj;
}
/// <summary>
/// Overrides handling of the property change to provent posting value if property
/// value got changed outside of the control.
/// </summary>
/// <param name="sender">Event sender.</param>
/// <param name="e">Property change event arguments.</param>
protected override void OnPropertyChange(object sender, PropertyChangeEventArgs e)
{
// prevent posting value if property value got changed outside of control
if (e.Change == PropertyChange.Value && PostedValue != "false") PreventModelUpdate = true;
base.OnPropertyChange(sender, e);
}
private void EditorState_SettingChanged(object sender, PropertyChangeEventArgs e)
{
if (e.PropertyName == nameof(EditorSettings.ActiveLayout))
{
this.ActiveLayout = (LayoutOrientation)e.NewValue;
}
}
public void Remove(string key)
{
if (m_propertyType != PropertyType.DictionaryType)
{
Debug.LogError("Function:Remove, PropertyType Error! Current type is" + m_propertyType.ToString());
return;
}
if (m_dictValue == null)
{
Debug.LogError("Function:Remove, Dictionary is empty!");
return;
}
if (!m_dictValue.ContainsKey(key))
{
Debug.LogError("Function:Remove, is not contains key!");
return;
}
PropertyChangeEventArgs msg = new PropertyChangeEventArgs(PropertyChangeType.REMOVE, m_dictValue[key], null, -1);
m_dictValue.Remove(key);
TriggerChangeEvent(msg);
}
private void OnPropertyChanged(object o, PropertyChangeEventArgs args)
{
if (args.PropertyName == "Name")
{
SetTitleText(args.NewValue.ToString());
}
}
void Document_PropertyChange(object sender, PropertyChangeEventArgs args)
{
if (args.Property == "ReadOnly")
{
tsiFileSave.Enabled = (mManager.ActiveDocument != null) && !mManager.ActiveDocument.ReadOnly;
}
}
public void Insert(int index, object arrayValue)
{
if (m_propertyType != PropertyType.ArrayValueType)
{
Debug.LogError("Function:Add, PropertyType Error! Current type is" + m_propertyType.ToString());
return;
}
if (index < 0 || (index > this.Count))
{
Debug.LogError("Function:Remove, index input ERROR!");
return;
}
if (m_arrayValue == null)
{
m_arrayValue = new ArrayList();
}
PropertyChangeEventArgs msg = new PropertyChangeEventArgs(PropertyChangeType.ADD, null, arrayValue, index);
m_arrayValue.Insert(index, arrayValue);
TriggerChangeEvent(msg);
}
private void OnPropertyChanged(object o, PropertyChangeEventArgs args)
{
if (args.PropertyName == "UnmapSourceActionLabel")
{
SetTitleText(args.NewValue.ToString());
}
}
public void Remove(T obj)
{
if (m_propertyType != PropertyType.ListValueType)
{
Debugging.LogError("Function:Remove, PropertyType Error! Current type is" + m_propertyType.ToString());
return;
}
if (m_listValue == null)
{
Debugging.LogError("Function:Remove, Array is empty!");
return;
}
int index = m_listValue.IndexOf(obj);
if (index < 0 || index >= m_listValue.Count)
{
Debugging.LogError("Function:Remove, index input ERROR!");
return;
}
PropertyChangeEventArgs msg = new PropertyChangeEventArgs(PropertyChangeType.REMOVE, m_listValue[index], null, index);
m_listValue.RemoveAt(index);
TriggerChangeEvent(msg);
}
private void TriggerChangeEvent(PropertyChangeEventArgs msg)
{
if (m_changeEvent != null)
{
m_changeEvent(this, msg);
}
}
private async Task OnCustomerChanged(object sender, PropertyChangeEventArgs e, CancellationToken token)
{
if (!e.Change.IncludesValue() || Equals(e.OldValue, e.NewValue) ||
PersonIdProperty.Value == null && StoreIdProperty.Value == null)
{
return;
}
int entityId = StoreIdProperty.Value == null ? // use store or person id
PersonIdProperty.Value.Value : StoreIdProperty.Value.Value;
await AddressLoader.SetParametersAsync(new Dictionary <string, object>() {
{ Enumerations.BusinessEntityAddress.Parameters.BusinessEntityId, entityId }
}, AddressLoader.LocalCache, token);
await BillingAddressObject.AddressIdProperty.ClearInvalidValues();
await ShippingAddressObject.AddressIdProperty.ClearInvalidValues();
var args = new PropertyChangeEventArgs(PropertyChange.Items, null, null, e.Row);
await BillingAddressObject.AddressIdProperty.FirePropertyChangeAsync(args, token);
await ShippingAddressObject.AddressIdProperty.FirePropertyChangeAsync(args, token);
Expression <Func <DataObject, bool> > lookUpEnabled = (obj) => obj.Editable;
LookupObject.LookUpAction.SetComputedEnabled(lookUpEnabled, this);
}
private void OnBroadcastDisabledChanged(object sender, PropertyEventArgs args)
{
if (args is PropertyChangeEventArgs)
{
PropertyChangeEventArgs pcargs = (PropertyChangeEventArgs)args;
m_BroadcastDisabled = (bool)pcargs.NewValue;
}
}
private void UpdateLineTotal(object sender, PropertyChangeEventArgs e)
{
if (e.Change.IncludesValue())
{
LineTotalProperty.SetValue(GetLineTotal(UnitPriceProperty.Value,
UnitPriceDiscountProperty.Value, OrderQtyProperty.Value));
}
}
void Document_PropertyChange(object sender, PropertyChangeEventArgs args)
{
if (args.Property == "FileName" || args.Property == "Modified")
{
TabText = String.Format("{0}{1}", Path.GetFileName(Document.FileName), Document.Modified ? " *" : "");
ToolTipText = Document.FileName;
}
}
private void CoreFirePropertyChanged(PropertyChangeEventArgs args)
{
OnPropertyChanged(args);
if (PropertyChanged != null)
{
PropertyChanged(this, args);
}
}
/// <summary>
/// Sets the current text whenever the property value changes.
/// </summary>
protected override void OnPropertyChange(PropertyChangeEventArgs e)
{
base.OnPropertyChange(e);
if (e.Change.IncludesValue())
{
CurrentText = Property.GetStringValue(ValueFormat.EditString, Row);
}
}
private void CoreFirePropertyChanging(PropertyChangeEventArgs args)
{
OnPropertyChanging(args);
if (PropertyChanging != null)
{
PropertyChanging(this, args);
}
IsFrozen.AssertFalse();
}
public void DomainObject_PropertyChanging(object sender, PropertyChangeEventArgs args)
{
_states.Add(new PropertyChangeState(sender, args.PropertyDefinition, args.OldValue, args.NewValue));
if (_states.Count == _cancelEventNumber)
{
CancelOperation();
}
}
private void DomainObject_PropertyChanged(object sender, PropertyChangeEventArgs args)
{
_hasChangedEventBeenCalled = true;
_changedPropertyDefinition = args.PropertyDefinition;
_changedOldValue = args.OldValue;
_changedNewValue = args.NewValue;
VerifyTransaction();
}
private void OnSourcePropertyChanged(object o, PropertyChangeEventArgs args)
{
if (args.PropertyName == "Nereid.SourceContents")
{
Banshee.ServiceStack.Application.Invoke(delegate {
UpdateSourceContents(previous_source);
});
}
}
public void FeetDisplayHandler(object sender, PropertyChangeEventArgs args)
{
UnityEngine.Debug.Log("Got feet display ID");
ObjectNode node = (ObjectNode)sender;
string feetDisplayID = (string)GetComponent<AtavismNode> ().GetProperty (args.PropertyName);
EquipmentDisplay display = ClientAPI.ScriptObject.GetComponent<Inventory>().LoadEquipmentDisplay(feetDisplayID);
//Material mat = feet.GetComponent<SkinnedMeshRenderer>().material;
//mat.SetTexture("_EquipmentTex", display.texture);
}
private void OnSourcePropertyChanged(object o, PropertyChangeEventArgs args)
{
if (args.PropertyName == "Nereid.SourceContents")
{
Banshee.Base.ThreadAssist.ProxyToMain(delegate {
UpdateSourceContents(previous_source);
});
}
}
public void HandleDeadState(object sender, PropertyChangeEventArgs args)
{
//Debug.Log ("Got dead update: " + oid);
long oid = GetComponent<AtavismNode>().Oid;
bool dead = (bool)AtavismClient.Instance.WorldManager.GetObjectNode(oid).GetProperty("deadstate");
if (dead) {
PlaySoundEvent(MobSoundEvent.Death);
}
}
private void OnFilmStripEnabledChanged(object sender, PropertyEventArgs args)
{
PropertyChangeEventArgs pcea = args as PropertyChangeEventArgs;
if (args != null)
{
this.Visible = (bool)pcea.NewValue;
}
}
/// <summary>
/// Updates the visibility and the Required flag of the additional properties
/// based on the currently selected operator. This method is triggered
/// whenever the current operator changes.
/// </summary>
/// <param name="sender">The event sender.</param>
/// <param name="e">Property change event arguments.</param>
protected void OnValueChanged(object sender, PropertyChangeEventArgs e)
{
if (!e.Change.IncludesValue() && !e.Change.IncludesVisible() || additionalProperty == null) return;
int depCnt = 0;
if (!IsNull()) Int32.TryParse("" + Value[AttributeAddlProps], out depCnt);
additionalProperty.Visible = Visible && depCnt > 0;
additionalProperty.Required = additionalProperty.Visible;
if (additionalProperty2 != null)
{
additionalProperty2.Visible = Visible && depCnt > 1;
additionalProperty2.Required = additionalProperty2.Visible;
}
}
private void TriggerChangeEvent(PropertyChangeEventArgs msg)
{
if (m_changeEvent != null)
m_changeEvent(this, msg);
}
public PropertyChangeUndoer(object sender, PropertyChangeEventArgs args)
{
this.m_Sender = sender;
this.m_Change = args;
}
public void HandleCombatState(object sender, PropertyChangeEventArgs args)
{
inCombat = (bool)AtavismClient.Instance.WorldManager.GetObjectNode(oid).GetProperty("combatstate");
if (_animator != null) {
AtavismLogger.LogDebugMessage("setting combat state for animator");
_animator.SetBool ("Combat", inCombat);
}
}
public void XpMaxHandler(object sender, PropertyChangeEventArgs args)
{
xpmax = (int)ClientAPI.GetPlayerObject().GetProperty(xp_max_prop);
}
public void ScaleHandler(object sender, PropertyChangeEventArgs args) {
AtavismLogger.LogDebugMessage("Got scale");
Vector3 scaleObj = (Vector3) GetComponent<AtavismNode>().GetProperty("scale");
gameObject.transform.localScale = scaleObj;
}
public void WeaponDisplayHandler(object sender, PropertyChangeEventArgs args)
{
UnityEngine.Debug.Log("Got weapon display ID");
ObjectNode node = (ObjectNode)sender;
string displayID = (string)GetComponent<AtavismNode> ().GetProperty (args.PropertyName);
// Remove existing item
if (attachedItems.ContainsKey(mainHand)) {
Destroy(attachedItems[mainHand]);
attachedItems.Remove(mainHand);
}
if (displayID != null && displayID != "") {
EquipmentDisplay display = ClientAPI.ScriptObject.GetComponent<Inventory>().LoadEquipmentDisplay(displayID);
GameObject weapon = (GameObject) Instantiate(display.model, mainHand.position, mainHand.rotation);
weapon.transform.parent = mainHand;
attachedItems.Add(mainHand, weapon);
}
}
/// <summary>
/// Retransmits property change events from any of the component properties
/// as its own property change event, so that the combined value would be refreshed.
/// </summary>
/// <param name="property">The component property that was changed.</param>
/// <param name="eventArgs">Event arguments that describe the property change.</param>
private void ComponentPropertyChange(object property, PropertyChangeEventArgs eventArgs)
{
FirePropertyChange(eventArgs);
}
private void OnSourcePropertyChanged(object o, PropertyChangeEventArgs args)
{
if (args.PropertyName == "Nereid.SourceContents") {
Banshee.Base.ThreadAssist.ProxyToMain (delegate {
UpdateSourceContents (previous_source);
});
}
}
public void HealthMaxHandler(object sender, PropertyChangeEventArgs args)
{
healthmax = (int)ClientAPI.GetPlayerObject().GetProperty(health_max_prop);
}
/// <summary>
/// Subclasses must call this method in their constructor in order to set up event listeners
/// and to invoke <see cref="SetUpMember"/> on each of the members already present in the
/// collection when the <see cref="PropertyCollectionHelper"/> is initialized.
/// </summary>
/// <remarks>
/// This method is not called by the base class constructor, in order to allow subclasses to perform
/// any necessary initialization in their own constructors before calls to <see cref="SetUpMember"/> are made.
/// </remarks>
/// <exception cref="InvalidOperationException">
/// If <see cref="Initialize"/> is called more than once.
/// </exception>
protected void Initialize()
{
// A lock is necessary in order to read the items from this.Collection,
// and also to synchronize on the PropertyCollectionHelper instead of lock(this).
// We can't use lock(this) because the lock ordering cannot be guaranteed.
using (Synchronizer.Lock(this.m_Owner.SyncRoot)) {
if (this.m_Initialized)
throw new InvalidOperationException("The PropertyCollectionHelper has already been initialized.");
this.m_Initialized = true;
// Set up event listeners.
this.m_HandlePropertyChangingDispatch = new EventQueue.PropertyEventDispatcher(this.m_EventQueue, new PropertyEventHandler(this.HandlePropertyChanging));
this.m_HandlePropertyChangedDispatch = new EventQueue.PropertyEventDispatcher(this.m_EventQueue, new PropertyEventHandler(this.HandlePropertyChanged));
// Call HandlePropertyChanged to set up each existing member in the collection.
object collection = this.Collection;
PropertyEventArgs args = new PropertyChangeEventArgs(this.Property, collection, collection);
this.m_HandlePropertyChangedDispatch.Dispatcher(this.m_Owner, args);
// Register the event listeners after setting up members so no member can get set up twice.
// (Not really a ThreadStart, but we just need a no-args delegate type.)
this.m_EventQueue.Post(delegate() {
using (Synchronizer.Lock(this.m_Owner.SyncRoot)) {
if (!this.m_Disposed) {
this.m_Owner.Changing[this.Property].Add(this.m_HandlePropertyChangingDispatch.Dispatcher);
this.m_Owner.Changed[this.Property].Add(this.m_HandlePropertyChangedDispatch.Dispatcher);
}
}
});
}
}
public void LevelHandler(object sender, PropertyChangeEventArgs args)
{
level = (int)ClientAPI.GetPlayerObject().GetProperty(level_prop);
}
public void WeaponDisplayHandler(object sender, PropertyChangeEventArgs args)
{
UnityEngine.Debug.Log("Got weapon display ID");
//ObjectNode node = (ObjectNode)sender;
string displayID = (string)GetComponent<AtavismNode> ().GetProperty (args.PropertyName);
SetWeaponDisplay(displayID);
}
private void OnPropertyChanged(object o, PropertyChangeEventArgs args)
{
if (args.PropertyName == "Name") {
SetTitleText (args.NewValue.ToString ());
}
}
public void Insert(int index, object arrayValue)
{
if (m_propertyType != PropertyType.ArrayValueType)
{
Debug.LogError("Function:Add, PropertyType Error! Current type is" + m_propertyType.ToString());
return;
}
if (index < 0 || (index > this.Count))
{
Debug.LogError("Function:Remove, index input ERROR!");
return;
}
if (m_arrayValue == null)
{
m_arrayValue = new ArrayList();
}
PropertyChangeEventArgs msg = new PropertyChangeEventArgs(PropertyChangeType.ADD, null, arrayValue, index);
m_arrayValue.Insert(index, arrayValue);
TriggerChangeEvent(msg);
}
public void Add(string key, object valueOf)
{
if (m_propertyType != PropertyType.DictionaryType)
{
Debug.LogError("Function:Add, PropertyType Error! Current type is" + m_propertyType.ToString());
return;
}
if (m_dictValue == null)
{
m_dictValue = new Dictionary<string, object>();
}
PropertyChangeEventArgs msg = new PropertyChangeEventArgs(PropertyChangeType.ADD, null, valueOf, -1);
m_dictValue.Add(key, valueOf);
TriggerChangeEvent(msg);
}
private void OnPropertyChanged(object o, PropertyChangeEventArgs args)
{
if (args.PropertyName == "Icon.Name") {
UpdateIcon ();
}
}
public void HandleDeadState(object sender, PropertyChangeEventArgs args)
{
dead = (bool)ClientAPI.GetPlayerObject().GameObject.GetComponent<AtavismNode>().GetProperty("deadstate");
}
/// <summary>
/// Overrides handling of the property change to always update the control
/// and also trigger stop editing if the control actually changed the property value.
/// </summary>
/// <param name="sender">Event sender.</param>
/// <param name="e">Property change event arguments.</param>
protected override void OnPropertyChange(object sender, PropertyChangeEventArgs e)
{
// prevent posting value if property value got changed
// outside of control (e.g. via cascading selection)
if (e.Change == PropertyChange.Value) PostedValue = null;
// change base behavior to always update the control
// e.g. to refresh a required dropdown list
bool b = PreventElementUpdate;
PreventElementUpdate = false;
base.OnPropertyChange(sender, e);
PreventElementUpdate = b;
// stop the editing (and hence trigger the editing end event),
// if the posted value actually changed the property value
if (property == sender && PreventElementUpdate &&
e.Change == PropertyChange.Value && !Equals(e.OldValue, e.NewValue))
property.Editing = false;
}
public void Remove(string key)
{
if (m_propertyType != PropertyType.DictionaryType)
{
Debug.LogError("Function:Remove, PropertyType Error! Current type is" + m_propertyType.ToString());
return;
}
if (m_dictValue == null)
{
Debug.LogError("Function:Remove, Dictionary is empty!");
return;
}
if (!m_dictValue.ContainsKey(key))
{
Debug.LogError("Function:Remove, is not contains key!");
return;
}
PropertyChangeEventArgs msg = new PropertyChangeEventArgs(PropertyChangeType.REMOVE, m_dictValue[key], null, -1);
m_dictValue.Remove(key);
TriggerChangeEvent(msg);
}
public void MovementStateHandler(object sender, PropertyChangeEventArgs args)
{
AtavismLogger.LogDebugMessage("Got movementstate");
AtavismObjectNode node = (AtavismObjectNode)sender;
int state = (int)GetComponent<AtavismNode> ().GetProperty (args.PropertyName);
if (isPlayer && state != 2 && transform.position.y < ClientAPI.Instance.WaterHeight) {
movementState = 2;
} else {
movementState = state;
}
}
public object this[string key]
{
get
{
if (m_propertyType != PropertyType.DictionaryType)
{
Debug.LogError("Function:GetDictionaryValue, PropertyType Error! Current type is" + m_propertyType.ToString());
return null;
}
if (m_dictValue == null || !m_dictValue.ContainsKey(key))
{
Debug.LogError("Function:GetDictionaryValue, is not contain key!");
return null;
}
return m_dictValue[key];
}
set
{
if (m_propertyType != PropertyType.DictionaryType)
{
Debug.LogError("Function:SetDictionaryValue, PropertyType Error! Current type is" + m_propertyType.ToString());
}
if (m_dictValue == null)
{
Debug.LogError("Function:SetDictionaryValue, Dictionary is empty!");
return;
}
if (!m_dictValue.ContainsKey(key))
{
Debug.LogError("Function:SetDictionaryValue, is not contain key!");
return;
}
PropertyChangeEventArgs msg = new PropertyChangeEventArgs(PropertyChangeType.UPDATE, m_dictValue[key], value, -1);
m_dictValue[key] = value;
TriggerChangeEvent(msg);
}
}
public void HandleWeaponType(object sender, PropertyChangeEventArgs args)
{
if (useAnimator) {
if (_animator == null)
{
_animator = (Animator)GetComponentInChildren(typeof(Animator));
}
} else {
return;
}
if (weaponType != null && weaponType != "" && weaponType != "Unarmed") {
_animator.SetBool (weaponType, false);
}
weaponType = (string)AtavismClient.Instance.WorldManager.GetObjectNode(oid).GetProperty("weaponType");
if (_animator != null && weaponType != "" && weaponType != "Unarmed") {
AtavismLogger.LogDebugMessage("setting combat state for animator");
_animator.SetBool (weaponType, true);
}
}
public void RemoveAt(int index)
{
if (m_propertyType != PropertyType.ArrayValueType)
{
Debug.LogError("Function:RemoveAt, PropertyType Error! Current type is" + m_propertyType.ToString());
return;
}
if ((m_arrayValue == null) || (index < 0 || index >= m_arrayValue.Count))
{
Debug.LogError("Function:RemoveAt, index input ERROR!");
return;
}
PropertyChangeEventArgs msg = new PropertyChangeEventArgs(PropertyChangeType.REMOVE, m_arrayValue[index], null, index);
m_arrayValue.RemoveAt(index);
TriggerChangeEvent(msg);
}
public void HandleDeadState(object sender, PropertyChangeEventArgs args)
{
//Debug.Log ("Got dead update: " + oid);
dead = (bool)AtavismClient.Instance.WorldManager.GetObjectNode(oid).GetProperty("deadstate");
if (dead) {
// Play death animation
if (_animation) {
_animation.CrossFade (deathAnimation.name);
} else if (_animator) {
_animator.SetBool ("Dead", true);
}
target = -1;
}
//Debug.Log ("Set dead state to: " + dead);
}
private void OnSourcePropertyChanged (object o, PropertyChangeEventArgs args)
{
switch (args.PropertyName) {
case "Nereid.SourceContents":
ThreadAssist.ProxyToMain (delegate {
UpdateSourceContents (previous_source);
});
break;
case "FilterQuery":
var source = ServiceManager.SourceManager.ActiveSource;
var search_entry = source.Properties.Get<SearchEntry> ("Nereid.SearchEntry") ?? view_container.SearchEntry;
if (!search_entry.HasFocus) {
ThreadAssist.ProxyToMain (delegate {
view_container.SearchEntry.Ready = false;
view_container.SearchEntry.Query = source.FilterQuery;
view_container.SearchEntry.Ready = true;
});
}
break;
case "Nereid.SimpleUI":
SetSimple (ServiceManager.SourceManager.ActiveSource.Properties.Get<bool> ("Nereid.SimpleUI"));
break;
}
}
public void ManaMaxHandler(object sender, PropertyChangeEventArgs args)
{
manamax = (int)ClientAPI.GetPlayerObject().GetProperty(mana_max_prop);
}
