// These are used by the 2 constructor overloads that don't take int
//private ModelVisual3D _dotModel = null;
//private ModelVisual3D _velocityModel = null;
//private ModelVisual3D _accelerationModel = null;
#endregion
#region Constructor
public PointVisualizer(Viewport3D viewport, SharedVisuals sharedVisuals)
{
_viewport = viewport;
_sharedVisuals = sharedVisuals;
_items = new ItemProperties[3];
// Position
_items[INDEX_POSITION] = new ItemProperties();
_items[INDEX_POSITION].IsPoint = true;
_items[INDEX_POSITION].Color = Colors.Magenta;
_items[INDEX_POSITION].SizeMultiplier = 1d;
// Velocity
_items[INDEX_VELOCITY] = new ItemProperties();
_items[INDEX_VELOCITY].IsPoint = false;
_items[INDEX_VELOCITY].Color = Colors.Chartreuse;
_items[INDEX_VELOCITY].SizeMultiplier = 1d;
// Acceleration
_items[INDEX_ACCELERATION] = new ItemProperties();
_items[INDEX_ACCELERATION].IsPoint = false;
_items[INDEX_ACCELERATION].Color = Colors.Gold;
_items[INDEX_ACCELERATION].SizeMultiplier = 1d;
}
bool Contains(ItemProperties item)
{
foreach (ItemSlot s in Slots)
{
if (s.Item == null)
{
continue;
}
if (s.Item.Properties == item)
{
return(true);
}
}
return(false);
}
private void PickingItem(GameObject item)
{
showItem = item;
Canvas.SetActive(showItem != null);
ItemProperties properties = showItem.GetComponent <ItemProperties>();
if (properties != null)
{
Canvas.GetComponent <CanvasProperties>().SetTextMesh(0, showItem.GetComponent <ItemProperties>().itemName);
Canvas.GetComponent <CanvasProperties>().SetAlpha(itemNameDisplayAlpha, itemNameDisplaySpeed);
Canvas.GetComponent <CanvasProperties>().SetTextColor(0, showItem.GetComponent <ItemProperties>().textColor);
Canvas.GetComponent <CanvasProperties>().SetTextMesh(1, controller.PickupKey.ToString());
}
}
public PropertyDescriptorCollection GetItemProperties(PropertyDescriptor[] listAccessors)
{
if (listAccessors == null || listAccessors.Length == 0)
{
return(new PropertyDescriptorCollection(ItemProperties.ToArray()));
}
var propertyDescriptor = listAccessors[listAccessors.Length - 1];
var collectionInfo = ViewInfo.DataSchema.GetCollectionInfo(propertyDescriptor.PropertyType);
if (collectionInfo != null)
{
return(new PropertyDescriptorCollection(ViewInfo.DataSchema.GetPropertyDescriptors(collectionInfo.ElementType).ToArray()));
}
return(new PropertyDescriptorCollection(ViewInfo.DataSchema.GetPropertyDescriptors(propertyDescriptor.PropertyType).ToArray()));
}
protected void MatchItemPropertyField_SelectedIndexChanged(object sender, EventArgs e)
{
if (sender != null)
{
DropDownList itemPropertyField = (DropDownList)sender;
DropDownList customPropertyField =
(DropDownList)itemPropertyField.NamingContainer.FindControl("MatchCustomPropertyField");
HelpLabel customPropertyLabel =
(HelpLabel)itemPropertyField.NamingContainer.FindControl("MatchCustomPropertyLabel");
ItemProperties itemProperty =
(ItemProperties)Enum.Parse(typeof(ItemProperties), itemPropertyField.SelectedValue);
PrepareCustomPropertyField(customPropertyLabel, customPropertyField, itemProperty);
}
}
public void Remove(ItemProperties item, byte num)
{
foreach (ItemSlot s in Slots)
{
if (s.Item == null)
{
continue;
}
if (s.Item.Properties == item)
{
s.Remove(num);
break;
}
}
}
protected void ValueOrderPropertyField_SelectedIndexChanged(object sender, EventArgs e)
{
if (sender != null)
{
DropDownList orderPropertyField = (DropDownList)sender;
DropDownList itemPropertyField = (DropDownList)orderPropertyField.NamingContainer.FindControl("ValueItemPropertyField");
DropDownList packagePropertyField = (DropDownList)orderPropertyField.NamingContainer.FindControl("ValuePackagePropertyField");
DropDownList customPropertyField = (DropDownList)orderPropertyField.NamingContainer.FindControl("ValueCustomPropertyField");
HelpLabel customPropertyLabel = (HelpLabel)orderPropertyField.NamingContainer.FindControl("ValueCustomPropertyLabel");
Label multiplierLabel = (Label)orderPropertyField.NamingContainer.FindControl("ValueMultiplierLabel");
HelpLabel valueLabel = (HelpLabel)orderPropertyField.NamingContainer.FindControl("ValueLabel");
TextBox valueField = (TextBox)orderPropertyField.NamingContainer.FindControl("ValueField");
BaseValidator valueRequired = (BaseValidator)orderPropertyField.NamingContainer.FindControl("ValueRequired");
BaseValidator valueNumeric = (BaseValidator)orderPropertyField.NamingContainer.FindControl("ValueNumeric");
OrderProperties orderProperty = (OrderProperties)Enum.Parse(typeof(OrderProperties), orderPropertyField.SelectedValue);
ItemProperties itemProperty = (ItemProperties)Enum.Parse(typeof(ItemProperties), itemPropertyField.SelectedValue);
PackageProperties packageProperty = (PackageProperties)Enum.Parse(typeof(PackageProperties), packagePropertyField.SelectedValue);
if (orderProperty == OrderProperties.ItemProperty)
{
itemPropertyField.Visible = true;
packagePropertyField.Visible = false;
PrepareCustomPropertyField(customPropertyLabel, customPropertyField, itemProperty);
PrepareValueField(multiplierLabel, valueLabel, valueField, valueRequired, valueNumeric, itemProperty);
}
else if (orderProperty == OrderProperties.PackageProperty)
{
itemPropertyField.Visible = false;
packagePropertyField.Visible = true;
PrepareCustomPropertyField(customPropertyLabel, customPropertyField, packageProperty);
PrepareValueField(multiplierLabel, valueLabel, valueField, valueRequired, valueNumeric, packageProperty);
}
else
{
itemPropertyField.Visible = false;
packagePropertyField.Visible = false;
customPropertyField.Visible = false;
PrepareValueField(multiplierLabel, valueLabel, valueField, valueRequired, valueNumeric, orderProperty);
Page.Validate("RuleGroup");
if (Page.IsValid)
{
PrepareCustomPropertyField(customPropertyLabel, customPropertyField, orderProperty);
}
}
}
}
public bool RemoveItem(int ItemIndex)
{
ItemProperties newItem = items[ItemIndex];
if (items.Count > 0)
{
if (items.Remove(newItem))
{
currentWeight -= newItem.itemWeight;
return(true);
}
}
return(false);
}
public int Remove(int itemId, int amount = 1, ItemProperties properties = null)
{
ItemStorage.InventoryItemX inventoryItemX;
while (amount > 0 && (inventoryItemX = this._usedSlots.LastOrDefault((ItemStorage.InventoryItemX s) => s._itemId == itemId && s._properties.Match(properties))) != null)
{
amount = inventoryItemX.RemoveOverflow(amount);
if (inventoryItemX._amount == 0)
{
int index = this._usedSlots.IndexOf(inventoryItemX);
this._usedSlots.RemoveAt(index);
this.UpdateContentVersion();
}
}
this.UpdateFillIcon();
return(amount);
}
void instantiateEditorForProperties(ItemProperties itemProperties)
{
string editorName = @"{0}Editor".FormatWith(itemProperties.GetType( ).Name);
Type t = Type.GetType(editorName);
if (t == null)
{
throw new InvalidOperationException(
@"Cannot instantiate an editor named '{0}' for the item properties of type '{1}'. No such editor exists.".
FormatWith(
editorName, itemProperties.GetType( )));
}
Activator.CreateInstance(t, this, itemProperties);
}
/// <summary>
/// This is used if you call the constructor that takes an integer. Don't use the public properties, call this method instead for each of the items
/// to be drawn
/// </summary>
/// <param name="isPoint">
/// True: This will draw a sphere
/// False: This will draw a line
/// </param>
/// <param name="sizeMultiplier">
/// If isPoint is true, this is the radius. If false, this is the line length multiplier
/// </param>
public void SetCustomItemProperties(int index, bool isPoint, Color color, double sizeMultiplier)
{
if (_isPosVelAcc)
{
throw new InvalidOperationException("This can't be used when the position/velocity/acceleration constructors were called");
}
ClearModels();
_items[index] = new ItemProperties();
_items[index].IsPoint = isPoint;
_items[index].Color = color;
_items[index].SizeMultiplier = sizeMultiplier;
// The first call to update will initialize the models
}
private void SendPropertiesEvent()
{
var inst = new ItemProperties {
ItemId = nebulaObject.Id,
ItemType = nebulaObject.Type,
PropertiesRevision = nebulaObject.properties.propertiesRevision,
PropertiesSet = nebulaObject.properties.raw
};
var evtData = new EventData((byte)EventCode.ItemProperties, inst);
SendParameters sendParameters = new SendParameters {
ChannelId = Settings.ItemEventChannel
};
var message = new ItemEventMessage(nebulaObject as Item, evtData, sendParameters);
(nebulaObject as Item).EventChannel.Publish(message);
}
public FilterResult Evaluate(ItemCraft item, ItemProperties props, IDictionary <string, double> stats)
{
if (Subconditions == null)
{
return new FilterResult()
{
Match = true
}
}
;
int count = 0;
IDictionary <string, double> info = new Dictionary <string, double>()
{
{ "Count", 0 }
};
foreach (FilterCondition c in Subconditions)
{
FilterResult r = c.Evaluate(item, props, stats);
if (r.Match)
{
count++;
}
if (r.Info != null)
{
foreach (string s in r.Info.Keys)
{
string testkey = s;
int n = 2;
while (info.ContainsKey(testkey) && testkey.IndexOf("[pseudo]") < 0) //guarantee unique key if it's a count or weight
{
testkey = s + "(" + n + ")";
n++;
}
info.Add(testkey, r.Info[s]);
}
}
}
info["Count"] = count;
bool match = (Min == null || count >= Min) && (Max == null || count <= Max);
return(new FilterResult()
{
Match = match, Info = info
});
}
private void PickupItem(GameObject item)
{
handObject = item;
handObject.transform.position = transform.position;
handObject.transform.rotation = transform.rotation;
handObject.GetComponent <Collider>().enabled = false;
handObject.GetComponent <Rigidbody>().isKinematic = true;
handObject.transform.parent = transform;
m_isHandBusy = true;
ItemProperties itemProperties = handObject.GetComponent <ItemProperties>();
itemProperties.isInUse = true;
itemProperties.Highlight(false);
m_otherDevicePickupSystem.RemoveItemFromRange(item);
}
public XElement ToXml()
{
var props = ItemProperties.Where(a => !a.UseDefaultValue);
return(new XElement("Item",
new XElement("Name", this.ItemName),
new XElement("Id", this.ItemID),
new XElement("DefaultName", this.DefaultName),
new XElement("Description", this.Description.ToXML()),
new XElement("ItemClass", this.ItemClassParent.Name),
new XElement("Removable", this.Removable),
new XElement("Properties", from a in this.ItemProperties select a.ToXml()),
new XElement("OnUse", this.OnUse.ToXML()),
new XElement("Icon", this.Icon),
new XElement("IsEquipment", this.IsEquipment),
EquipmentRef.ToXML()));
}
private void ThrowItem(ImportedItem item, ScreenSegment segment)
{
GameObject spawnedObject = Instantiate(item.gameObject, spawnPoint, transform.rotation);
broker.Register(segment, spawnedObject);
ItemProperties properties = item.itemProperties;
Rigidbody rigidBody = spawnedObject.GetComponent <Rigidbody>();
rigidBody.mass = properties.mass;
Vector3 side;
Vector3 up;
Vector3 towards;
switch (segment)
{
case ScreenSegment.TOP_LEFT:
side = properties.forceSide * Vector3.left;
up = properties.forceUpHigh * Vector3.up;
towards = properties.forceBack * Vector3.back;
break;
case ScreenSegment.BOTTOM_LEFT:
side = properties.forceSide * Vector3.left;
up = properties.forceUpLow * Vector3.up;
towards = properties.forceBack * Vector3.back;
break;
case ScreenSegment.TOP_RIGHT:
side = properties.forceSide * Vector3.right;
up = properties.forceUpHigh * Vector3.up;
towards = properties.forceBack * Vector3.back;
break;
default:
side = properties.forceSide * Vector3.right;
up = properties.forceUpLow * Vector3.up;
towards = properties.forceBack * Vector3.back;
break;
}
rigidBody.AddForce(side + up + towards);
}
protected void MatchOrderPropertyField_SelectedIndexChanged(object sender, EventArgs e)
{
if (sender != null)
{
DropDownList orderPropertyField = (DropDownList)sender;
DropDownList itemPropertyField =
(DropDownList)orderPropertyField.NamingContainer.FindControl("MatchItemPropertyField");
DropDownList packagePropertyField =
(DropDownList)orderPropertyField.NamingContainer.FindControl("MatchPackagePropertyField");
DropDownList customPropertyField =
(DropDownList)orderPropertyField.NamingContainer.FindControl("MatchCustomPropertyField");
HelpLabel customPropertyLabel =
(HelpLabel)orderPropertyField.NamingContainer.FindControl("MatchCustomPropertyLabel");
OrderProperties orderProperty =
(OrderProperties)Enum.Parse(typeof(OrderProperties), orderPropertyField.SelectedValue);
ItemProperties itemProperty =
(ItemProperties)Enum.Parse(typeof(ItemProperties), itemPropertyField.SelectedValue);
PackageProperties packageProperty =
(PackageProperties)Enum.Parse(typeof(PackageProperties), packagePropertyField.SelectedValue);
if (orderProperty == OrderProperties.ItemProperty)
{
itemPropertyField.Visible = true;
packagePropertyField.Visible = false;
PrepareCustomPropertyField(customPropertyLabel, customPropertyField, itemProperty);
}
else if (orderProperty == OrderProperties.PackageProperty)
{
itemPropertyField.Visible = false;
packagePropertyField.Visible = true;
PrepareCustomPropertyField(customPropertyLabel, customPropertyField, packageProperty);
}
else
{
itemPropertyField.Visible = false;
packagePropertyField.Visible = false;
customPropertyField.Visible = false;
Page.Validate("RuleGroup");
if (Page.IsValid)
{
PrepareCustomPropertyField(customPropertyLabel, customPropertyField, orderProperty);
}
}
}
}
public void ActionSelectItem(ItemProperties item)
{
if (state == BattleState.BAG)
{
inv.closeInventory();
action = ActionType.ITEM;
used_item_prop = new ItemProperties(item);
if (effective_stats[(int)Stat.SPD] >= enemy.GetSPD())
{
state = BattleState.P1;
}
else
{
state = BattleState.P2;
statGen.addProb((int)Stat.SPD);//SPEED INCREASES IF PLAYER GOES SECOND TODO
}
}
}
/// <summary>
/// Handles actions occurring when some item is deleted.
/// </summary>
/// <param name="argument">Argument holding information on deleted item</param>
private void HandleDeleteAction(string argument)
{
if (!string.IsNullOrEmpty(argument))
{
string[] argArr = argument.Split(ARG_SEPARATOR);
if (argArr.Length >= 2)
{
// Get information from argument
string path = argArr[0];
bool isFile = ValidationHelper.GetBoolean(argArr[2], true);
if (path.StartsWithCSafe(NodeID, true))
{
if (isFile && File.Exists(path))
{
File.Delete(path);
}
else if (Directory.Exists(path))
{
Directory.Delete(path);
}
}
else
{
ShowError(GetString("dialogs.filesystem.invalidfilepath"));
}
// Load new data filtered by searched text
fileSystemView.SearchText = LastSearchedValue;
fileSystemView.StartingPath = NodeID;
// Reload the file system view
fileSystemView.Reload();
pnlUpdateView.Update();
// Clear selected item
ItemProperties.ClearProperties();
pnlUpdateProperties.Update();
}
}
// Forget recent action
ClearActionElems();
}
public void TakeItem()
{
//search the backweapon list and enable it
GameObject newWeapon = controller.AttackScript.secondWeaponParent.Find(showItem.GetComponent <ItemProperties>().itemName).gameObject;
newWeapon.SetActive(true);
if (controller.AttackScript.secondWeapon != null)
{
//drop item
controller.AttackScript.secondWeapon.gameObject.SetActive(false);
ItemProperties newProperties = controller.AttackScript.secondWeapon.GetComponent <ItemProperties>();
if (newProperties != null)
{
ItemProperties properties = showItem.GetComponent <ItemProperties>();
// apply new properties to the item
properties.itemName = newProperties.itemName;
properties.visualMesh = newProperties.visualMesh;
properties.textColor = newProperties.textColor;
properties.visualScale = newProperties.visualScale;
properties.turnRate = newProperties.turnRate;
properties.YAxis = newProperties.YAxis;
properties.initiateRotate = newProperties.initiateRotate;
// apply physically
properties.ResetItem();
// apply to the UI
PickingItem(showItem);
// reset tranform
showItem.transform.position = new Vector3(transform.position.x,
controller.AttackScript.secondWeaponParent.transform.position.y + 0.5f,
transform.position.z);
// toss it to a random direction with constant force apply
Vector3 torque;
torque.x = (Random.Range(0, 2) * 2 - 1) * tossItemForce;
torque.y = Random.Range(4, 5);
torque.z = (Random.Range(0, 2) * 2 - 1) * tossItemForce;
showItem.GetComponent <Rigidbody>().AddForce(torque, ForceMode.Impulse);
}
}
else
{
Destroy(showItem);
}
controller.AttackScript.secondWeapon = newWeapon.transform;
}
public void PopulateProperties()
{
ItemClass parentClass = this.ItemClassParent;
while (parentClass != null)
{
foreach (var property in parentClass.ItemProperties)
{
ItemProperties.Add(new ItemProperty()
{
Name = parentClass.Name + ":" + property.Name,
BaseVariable = property,
Value = property.GetDefaultValue()
});
}
parentClass = parentClass.ParentClass;
}
}
private void Item_PropertyChanged(object item, PropertyChangedEventArgs args)
{
var notifier = item as NestedPropertyChangedNotifier <T>;
Debug.Assert(notifier != null);
int pos = base.IndexOf(notifier.Object);
if (pos == -1)
{
Debug.Fail("Item not in list.");
RemovePropertyChangedNotifier(notifier.Object);
return;
}
var pd = ItemProperties.Find(args.PropertyName, true);
OnListChanged(new ListChangedEventArgs(ListChangedType.ItemChanged, pos, pd));
}
public override void UpdateObject()
{
_itemUI = obj as ItemProperties;
// set the visible data
if (_itemUI)
{
_image.sprite = _itemUI.sprite;
_text.text = _itemUI.amount.ToString();
if (slot != null)
{
InventoryUI.Instance.ReArrange(obj.name, slot.index, _itemUI.uiIndex);
}
}
// turn off if it was null
gameObject.SetActive(_itemUI != null);
}
private void OnIndexAdded(object sender, LogIndexAddedEventArgs e)
{
ItemProperties properties = null;
if (Array.Exists <string>(e.AddedIndexes, x => string.CompareOrdinal(x, ItemID) == 0))
{
properties = m_Database.GetItemProperties(ItemID);
}
if (properties != null)
{
string unit = properties["Unit"];
if (!string.IsNullOrEmpty(unit))
{
Label.Text = string.Format("{0} ({1})", ItemID, unit);
}
}
}
public bool HasProperty(ItemProperties property)
{
if (Ground != null && Ground.HasProperty(property))
{
return(true);
}
if (Items != null)
{
foreach (Item item in Items)
{
if (item.HasProperty(property))
{
return(true);
}
}
}
return(false);
}
IBehaviour buildBehaviour(ITreeItem forEditor)
{
ItemProperties itemProperties = forEditor.ItemProperties;
var behaviour = new FloatAnimationBehaviour(
itemProperties,
new FloatAnimationBehaviourProperties
{
DurationInSeconds = .75f,
Easing = Easing.EaseInOut,
From = 0,
To = 0,
Name = @"float_animation_{0}".FormatWith(IoC.Model.NextItemNumber),
NameOfPropertyToModify = @"Foo",
ClrTypeOfInterpolator = typeof(Quartic).AssemblyQualifiedName
});
return(behaviour);
}
public Pickeditem(Pickeditem _obj)
{
m_obj = (GameObject)GameObject.Instantiate(_obj.m_obj);
m_itemInfo = m_obj.GetComponent <ItemProperties>();
GameObject.DestroyImmediate(m_obj.GetComponent <Rigidbody>());
if (m_obj.GetComponent <BoxCollider>())
{
m_obj.GetComponent <BoxCollider>().isTrigger = true;
}
else if (m_obj.GetComponent <SphereCollider>())
{
m_obj.GetComponent <SphereCollider>().isTrigger = true;
}
else
{
mergeType = Powers.Convert;
m_itemInfo.setPartValue(_obj.m_itemInfo.p1, _obj.m_itemInfo.p2);
m_obj.GetComponent <CapsuleCollider>().isTrigger = true;
}
m_obj.layer = LayerMask.NameToLayer("Picked");
m_obj.transform.localScale = Vector3.zero; // Start skala
setMoveTo = Positions.AddSub;
setScaleTo = Scaling.PickupScale;
if (_obj.m_itemInfo.hasItem != null)
{
m_merge = _obj.m_itemInfo.hasItem;
m_itemInfo.setValue = _obj.m_itemInfo.setValue;
mergeType = Powers.Division;
}
m_itemInfo.setValue = _obj.m_itemInfo.setValue;
oldValue = m_itemInfo.setValue;
oldPosNeg = m_itemInfo.isNegative;
StartMS(true, true);
m_itemInfo.SpawnHitParticles();
}
/// <summary>
/// Loads selected item parameters into the selector.
/// </summary>
/// <param name="properties">Name-value collection representing item to load</param>
public void LoadSelectedItem(Hashtable properties)
{
if ((properties != null) && (properties.Count > 0))
{
Hashtable temp = (Hashtable)properties.Clone();
if ((properties[DialogParameters.AV_URL] != null) && ((properties[DialogParameters.LAST_TYPE] == null) || ((MediaTypeEnum)properties[DialogParameters.LAST_TYPE] == MediaTypeEnum.AudioVideo)))
{
drpMediaType.SelectedValue = "av";
txtUrl.Text = properties[DialogParameters.AV_URL].ToString();
}
else if ((properties[DialogParameters.FLASH_URL] != null) && ((properties[DialogParameters.LAST_TYPE] == null) || ((MediaTypeEnum)properties[DialogParameters.LAST_TYPE] == MediaTypeEnum.Flash)))
{
drpMediaType.SelectedValue = "flash";
txtUrl.Text = properties[DialogParameters.FLASH_URL].ToString();
}
else if ((properties[DialogParameters.IMG_URL] != null) && ((properties[DialogParameters.LAST_TYPE] == null) || ((MediaTypeEnum)properties[DialogParameters.LAST_TYPE] == MediaTypeEnum.Image)))
{
drpMediaType.SelectedValue = "image";
// Update URL
string url = ValidationHelper.GetString(properties[DialogParameters.IMG_URL], "");
txtUrl.Text = url;
// Get original dimensions
GetExternalImageDimensions(url);
temp[DialogParameters.IMG_ORIGINALWIDTH] = mWidth;
temp[DialogParameters.IMG_ORIGINALHEIGHT] = mHeight;
}
else if ((properties[DialogParameters.URL_URL] != null) && ((properties[DialogParameters.LAST_TYPE] == null) || ((MediaTypeEnum)properties[DialogParameters.LAST_TYPE] == MediaTypeEnum.Unknown)))
{
txtUrl.Text = properties[DialogParameters.URL_URL].ToString();
}
if (!String.IsNullOrEmpty(txtUrl.Text))
{
ShowProperties();
// Load temp properties because ShowProperties() change original properties
ItemProperties.LoadItemProperties(temp);
}
}
}
/// <summary>
/// Returns selected item parameters as name-value collection.
/// </summary>
public void GetSelectedItem()
{
if (ItemProperties.Validate())
{
// Get selected item information
var props = ItemProperties.GetItemProperties();
// Get JavaScript for inserting the item
var script = CMSDialogHelper.GetFileSystemItem(props);
if (!string.IsNullOrEmpty(script))
{
ScriptManager.RegisterStartupScript(Page, typeof(Page), "insertItemScript", script, true);
}
}
else
{
// Display error message
pnlUpdateProperties.Update();
}
}
/// <summary>
/// Initalizes the dictionary database
/// </summary>
private void InitalizeDictionary()
{
_itemDict = new Dictionary <int, ItemBase>();
foreach (ItemBase entry in initalEntries)
{
if (entry == null)
{
continue;
}
ItemProperties props = entry.properties;
// test for duplicates
Debug.Assert(!_itemDict.ContainsKey(props.itemID),
"Item database found two matching ids! Each item must have a unique id! " + entry.gameObject.name);
_itemDict.Add(props.itemID, entry);
}
}
IBehaviour buildBehaviour(ITreeItem forItem)
{
ItemProperties itemProperties = forItem.ItemProperties;
var interpolationBehaviour = new PositionAnimationBehaviour(
itemProperties,
new PositionAnimationBehaviourProperties
{
DurationInSeconds = .75f,
Easing = Easing.EaseInOut,
From = itemProperties.Position,
To = Vector2.Zero,
Name = @"movement_animation_{0}".FormatWith(IoC.Model.NextItemNumber),
NameOfPropertyToModify = @"Position",
ClrTypeOfInterpolator = typeof(Quartic).AssemblyQualifiedName,
});
return(interpolationBehaviour);
}
/// <summary>
/// This is used if you call the constructor that takes an integer. Don't use the public properties, call this method instead for each of the items
/// to be drawn
/// </summary>
/// <param name="isPoint">
/// True: This will draw a sphere
/// False: This will draw a line
/// </param>
/// <param name="sizeMultiplier">
/// If isPoint is true, this is the radius. If false, this is the line length multiplier
/// </param>
public void SetCustomItemProperties(int index, bool isPoint, Color color, double sizeMultiplier)
{
if (_isPosVelAcc)
{
throw new InvalidOperationException("This can't be used when the position/velocity/acceleration constructors were called");
}
ClearModels();
_items[index] = new ItemProperties();
_items[index].IsPoint = isPoint;
_items[index].Color = color;
_items[index].SizeMultiplier = sizeMultiplier;
// The first call to update will initialize the models
}
public ItemNode(VsSolutionHierarchyNode hierarchyNode, Lazy<ISolutionExplorerNode> parentNode, ISolutionExplorerNodeFactory nodeFactory)
: base(SolutionExplorerNodeKind.Item, hierarchyNode, parentNode, nodeFactory)
{
m_dteProjectItem = new Lazy<EnvDTE.ProjectItem>(() => (EnvDTE.ProjectItem)hierarchyNode.ExtenderObject);
Properties = new ItemProperties(this);
}
private void PrepareCustomPropertyField(WebControl label, ListControl list, ItemProperties property)
{
list.Items.Clear();
if (property == ItemProperties.CustomProperty)
{
label.ToolTip = "<p>Select the custom property to use.</p>";
list.Items.AddRange(GetPropertyTypes());
list.Visible = true;
}
else if (property == ItemProperties.Manufacturer || property == ItemProperties.Vendor)
{
label.ToolTip = string.Format("<p>Select the {0} property to use.</p>", property.ToString().ToLower());
list.Items.AddRange(GetVendorManufacturerProperties());
list.Visible = true;
}
else
{
label.ToolTip = "";
list.Items.Add(new ListItem("n/a", ""));
list.Visible = false;
}
}
private static void PrepareLimitField(Control multiplier, Label label, Control field, WebControl requiredValidator, WebControl numericValidator, ItemProperties property)
{
PropertyTypes propertyType = ItemPropertiesHelper.GetPropertyType(property);
PrepareLimitField(multiplier, label, field, requiredValidator, numericValidator, propertyType);
}
public void PackItemToAsset(string name, string type, string description, int price, int lvl, int dmg, int defence)
{
Item item;
item = ScriptableObject.CreateInstance<Item>();
ItemTypes t = (ItemTypes)Enum.Parse(typeof(ItemTypes), type);
ItemProperties properties = new ItemProperties(name, t, description, price, lvl, dmg, defence);
item.ItemProperties = properties;
ScriptableObjectUtility.CreateAsset(item, item.ItemProperties.ItemName);
}
