public void ReCreate(VisifireElement element, ElementTypes elementType, VcProperties property, object oldValue, object newValue) { //Type elementType = element.GetType(); // Create a plot groups list // this.PlotGroups = new List<PlotGroup>(); CalculateInternalXValue4NumericAxis(Chart); // Set default chart orientation if((elementType == ElementTypes.Chart && property == VcProperties.Series) ||(elementType == ElementTypes.DataSeries && property == VcProperties.RenderAs) ) this.ChartOrientation = ChartOrientationType.Undefined; // Validate XValue type of the DataPoint and DataSeries if ((elementType == ElementTypes.Chart && property == VcProperties.Series) || (elementType == ElementTypes.DataSeries && property == VcProperties.RenderAs) || (elementType == ElementTypes.DataPoint && property == VcProperties.XValue) || (elementType == ElementTypes.Chart && property == VcProperties.None) ) SetDataPointsNameAndValidateDataPointXValueType(); // Calculate all the required details this.Calculate(element, elementType, property, oldValue, newValue); }
public InstructionSet BuildPath(Point Start, ElementTypes Type, Direction CurrentDirection) { AlreadySearched = new List<Node>(); Shortest = null; distance = int.MaxValue; AlreadyTraveled = new List<Point>(); if (!GeneratedYet) GenerateMatrix(); Path N = FindClosestPath(Start, CurrentDirection); if (N != null) AlreadyTraveled.Add(N.Start.Location); InstructionSet Mine = new InstructionSet(); List<Path> Begin = new List<Path>(); Begin.Add(N); if (N != null) { BuildPath(new InstructionSet(Begin), Type, N.End); } //N.End.BuildPath(new InstructionSet(Begin), Type); return Shortest; }
public Town(Vector2 position, ControlledBy controlledBy, ElementTypes type, bool playerPresent) { _position = position; _controlledBy = controlledBy; _elementType = type; _playerPresent = playerPresent; _adjacentTownIndexes = new List<int>(); _underAttack = false; _turnsUntilTaken = 0; }
public void setTownType(ElementTypes type) { _townElement = type; if (_isNeutral) { _enemyElementCount = Manager.TownManager.GetElementCountForCharacter (ControlledBy.Enemy); } else { _enemyElementCount = 1; } }
/// <summary> /// Initialises a new instance of the ConstraintSignitureToken from the <paramref name="signiture"/> /// at the specified <paramref name="offset"/>. /// </summary> /// <param name="signiture">The signiture to load from.</param> /// <param name="offset">The offset in the signiture.</param> public ConstraintSignatureToken(byte[] signiture, Offset offset) : base(SignatureTokens.Constraint) { _constraint = (ElementTypes)GetCompressedValue(signiture, offset); }
public Element(int line, ElementTypes elementtype, Attribute list) { Line = line; ElementType = elementtype; AttributeList = list; }
internal abstract void PassClosingTag(ElementTypes ElementType);
public ElementAttribute(byte a, byte b, byte c, byte d, ElementTypes type, string description = null) : this(type, description) { ClassIdentifier = new ClassIdentifier(a, b, c, d); }
internal Element(int line, ElementTypes elementtype, Attribute list) { Line = line; ElementType = elementtype; AttributeList = list; AttributeCheck(); }
internal override void PassClosingTag(ElementTypes ElementType) { this.xmlReader.Read(); #if DEBUG if (this.xmlReader.NodeType != XmlNodeType.EndElement || this.xmlReader.Name != XmlSerializationFormatter.XmlElementNames[(int)ElementType]) throw new Exception( string.Format("Unattended xml element {0} while waiting a closing tag {1}", xmlReader.Name, ElementType.ToString())); #endif }
internal override bool GetNextElementAs( ref Element e, bool AcceptChannelSection, string Name, L3TypeManager SupposedType, bool NeedsThisElement, bool WantClosingElement) { bool SupposedTypeNumberIsKnown = SupposedType != null; // There is no tag for value primitive types: if (SupposedTypeNumberIsKnown && SupposedType.TypeIndex < (int)TypeCode.String && SupposedType.TypeIndex >= (int)TypeCode.Boolean) { e.ContainsAValue = true; e.ElementType = ElementTypes.PrimitiveValue; e.IsAClosingTag = true; e.typeIndex = SupposedType.TypeIndex; e.typeIndexIsKnown = true; return(true); } // There is no tag for structures: if (SupposedTypeNumberIsKnown && SupposedType.TypeIndex != (int)TypeCode.Object && SupposedType.l2TypeManager.L1TypeManager.IsStructure && (SupposedType.l2TypeManager.Container == null) && !SupposedType.l2TypeManager.L1TypeManager.IsNullable) { e.ContainsAValue = false; e.ElementType = ElementTypes.SubBranch; e.IsAClosingTag = true; e.typeIndex = SupposedType.TypeIndex; e.typeIndexIsKnown = true; return(true); } // 1) Element code : byte //int b = this.binaryReader.BaseStream.ReadByte(); // Unlike this.binaryReader.ReadByte(), this function does not cause an exception (exceptions can prevent method inlining). int b = this.binaryReader.ReadByteNoException(); // Unlike this.binaryReader.ReadByte(), this function does not cause an exception (exceptions can prevent method inlining). if (b < 0) #if DEBUG { throw new EndOfStreamException(); } #else { return(false); // end of file. } #endif byte elementCode = unchecked ((byte)b); if (elementCode == BinarySerializationFormatter.DataEndMarkCode) { return(false); // end of file. } ElementTypes et = (ElementTypes)(elementCode & (byte)BinaryElementCode.BitMask); #if DEBUG if (!AcceptChannelSection && !(et == ElementTypes.InstancesChannelSection || et == ElementTypes.TypesChannelSection)) { throw new Exception(); } #endif // 2) typeNumber : 7 bit-compressed int bool HasTypeNumber = (elementCode & (byte)BinaryAttributeCode.HasATypeNumber) != 0; #if DEBUG if (!SupposedTypeNumberIsKnown && !HasTypeNumber && (elementCode == (byte)BinaryElementCode.PrimitiveValue || elementCode == (byte)BinaryElementCode.SubBranch)) { throw new Exception(); } #endif int typeNumber = HasTypeNumber ? this.binaryReader.Read7BitEncodedInt() : (SupposedTypeNumberIsKnown ? SupposedType.TypeIndex : 0); // 3) Reference InstanceIndex : 7 bit-compressed int int?InstanceNumber = et == ElementTypes.Reference ? this.binaryReader.Read7BitEncodedInt() : (int?)null; // 4) NumberOfElements : 7 bit-compressed long bool HasANumberOfElements = (elementCode & (byte)BinaryAttributeCode.HasANumberOfElements) != 0; long?numberOfElements = HasANumberOfElements ? this.binaryReader.Read7BitEncodedLong() : (long?)null; #if DEBUG if (HasANumberOfElements && et != ElementTypes.SubBranch) { Debugger.Break(); } #endif e.ElementType = et; #if DEBUG e.Name = Name; #endif e.typeIndexIsKnown = SupposedTypeNumberIsKnown | HasTypeNumber; e.typeIndex = typeNumber; e.InstanceIndex = InstanceNumber; e.IsAClosingTag = true; e.NumberOfElements = numberOfElements; e.ContainsAValue = et == ElementTypes.PrimitiveValue; return(true); }
public ElementAttribute(ClassIdentifier identifier, ElementTypes type, string description = null) : this(type, description) { ClassIdentifier = identifier; }
private ElementAttribute(ElementTypes type, string description = null) { Type = type; Description = description; }
public Score(int score, string name, ElementTypes character) { NumericScore = score; Name = name; CharacterType = character; }
public ElementAttribute(byte a, byte b, byte c, byte d, ElementTypes type, string description = null) : this(type, description) { ClassIdentifier = new ClassIdentifier(a, b, c, d); }
public int getElementCountForPlayer(ElementTypes elementType) { int count = 0; foreach (Town town in _towns){ if (town._controlledBy == ControlledBy.Player && town._elementType == elementType) { count++; } } return count; }
// useless in this formatter. internal override void PassClosingTag(ElementTypes ElementType) { }
// -------------------------------------------- internal override void ChannelExitElement(ref ChannelInfos channelInfos, ElementTypes elementType) { }
/// <summary> /// Checks if the token a the <paramref name="offset"/> in the <paramref name="signiture"/> /// is one of the <paramref name="allowed"/> element types. /// </summary> /// <param name="signiture">The signiture blob.</param> /// <param name="offset">The offset in the signiture.</param> /// <param name="allowed">The allowed element type flags.</param> /// <returns>True of false</returns> public static bool IsToken(byte[] signiture, int offset, ElementTypes allowed) { ElementTypes value = (ElementTypes)GetCompressedValue(signiture, offset); return(value == allowed); }
public ElementDescriptor() { this.isDisabledField = false; this.isRequiredField = false; this.elementTypeField = ElementTypes.String; this.lengthLimitField = 0; }
/// <summary> /// Update the axis /// </summary> /// <param name="isSizeChanged"></param> internal void PrePartialUpdateConfiguration(VisifireElement sender, ElementTypes elementType, VcProperties property, object oldValue, object newValue, Boolean updateLists, Boolean calculatePlotDetails, Boolean updateAxis, AxisRepresentations renderAxisType, Boolean isPartialUpdate) { if (updateLists) PopulateInternalSeriesList(false); if (calculatePlotDetails) { PlotDetails.ReCreate(sender, elementType, property, oldValue, newValue); } if (updateLists) { SetDataPointColorFromColorSet(Chart.Series); } if (updateAxis) { PopulateInternalAxesXList(); PopulateInternalAxesYList(); ClearAxesPanel(); CreateTrendLinesLabel(); /* Size remainingSizeAfterDrawingAxes = RenderAxes(_plotAreaSize); */ //---------- Size remainingSizeAfterDrawingAxes = RenderAxes(_plotAreaSize); remainingSizeAfterDrawingAxes = RecalculateAxisAndRerenderBasedOnChartTypes(_plotAreaSize, remainingSizeAfterDrawingAxes); //----------- ResizePanels(remainingSizeAfterDrawingAxes, renderAxisType, isPartialUpdate); // Draw the chart grids if (PlotDetails.ChartOrientation != ChartOrientationType.NoAxis) { RenderGrids(); RenderTrendLines(); } } AddOrRemovePanels(Chart); }
public void PointerFollowedByNoCustomModsThenVoid_IsCorrect() { ElementTypes pointer = ElementTypes.Ptr; }
// ------------------------------ internal override void PassClosingTag(ElementTypes ElementType) { this.GetNextJSONPart(); if (this._JSONReader.Name == JSONSerializationFormatter.DataEndMarkTag) { this.WeAlreadyObtainedJSONPart = true; return; } #if DEBUG if (this._JSONReader.NodeType != XmlNodeType.EndElement || this._JSONReader.Name != JSONSerializationFormatter.JSONElementNames[(int)ElementType]) throw new Exception( string.Format("Unattended JSON element {0} while waiting a closing tag {1}", _JSONReader.Name, ElementType.ToString())); #endif }
public VirtualPlayer(Players playerType, ElementTypes element) : base(playerType, element) { }
private ElementAttribute(ElementTypes type, string description = null) { Type = type; Description = description; }
internal ElementInfos( ElementTypes ElementType, AttributeUsage[] AttributeUsages) { this.AttributeUsages = AttributeUsages; this.ElementType = ElementType; }
public bool IsType(ElementTypes Type, Point P) { foreach (Element E in FindAt(P)) { if (E.et == Type) { return true; } } return false; }
// Resolve all the custom attributes found in the assemblies registered // in 'resolver', using all the type information found in 'resolver' and // 'resolvers'. internal void resolveReferences(MetaDataResolver resolver, MetaDataResolver[] resolvers) { if (this.buffer[0] != 0x01 || this.buffer[1] != 0x00) { throw new MetaDataLoader.IllegalMetaDataFormatException("Custom Attribute doesn't start with 0x0001!"); } SignatureMethod signature; if (this.type is MetaDataMethod) { MetaDataMethod method = (MetaDataMethod)this.type; signature = (SignatureMethod)method.Signature; if (!method.Name.Equals(".ctor")) { throw new MetaDataLoader.IllegalMetaDataFormatException("Custom attribute with unexpected method name: " + method.Name); } this.typeDefOrRef = method.Parent; this.name = method.Parent.FullName; } else if (this.type is MetaDataMemberRef) { MetaDataMemberRef memberRef = (MetaDataMemberRef)this.type; signature = (SignatureMethod)memberRef.Signature; if (!memberRef.Name.Equals(".ctor")) { throw new MetaDataLoader.IllegalMetaDataFormatException("Custom attribute with unexpected memberRef name: " + memberRef.Name); } MetaDataObject methodParent = memberRef.Class; this.typeDefOrRef = methodParent; if (methodParent is MetaDataTypeDefinition) { this.name = ((MetaDataTypeDefinition)methodParent).FullName; } else if (methodParent is MetaDataTypeReference) { this.name = ((MetaDataTypeReference)methodParent).FullName; } else { throw new MetaDataLoader.IllegalMetaDataFormatException("Custom attribute with unexpected class type: " + methodParent); } } else { throw new MetaDataLoader.IllegalMetaDataFormatException("Custom attribute with unexpected type: " + this.type); } Signature.Param[] parameters = signature.Parameters; int fixedCount = parameters.Length; this.fixedArgs = new Object[fixedCount]; MemoryStream stream = new MemoryStream(this.buffer, 2, this.buffer.Length - 2, false); BinaryReader reader = new BinaryReader(stream); for (int i = 0; i < fixedCount; i++) { Signature.Param parameter = parameters[i]; Signature.Type paramType = parameter.Type; Object value = ExtractParameter(paramType, reader, resolver, resolvers); fixedArgs[i] = value; } short namedCount = ((reader.PeekChar() == -1) ? (short)0 : reader.ReadInt16()); if (namedCount > this.buffer.Length && this.Name.Equals("System.Runtime.CompilerServices.RequiredAttributeAttribute")) { // Some CLR libraries have been compiled against a version of // mscorlib that had a fixed parameter to RequiredAttribute. // Simply ignore whatever the parameter was! namedCount = 0; } this.namedArgs = new NamedArg[namedCount]; for (int i = 0; i < namedCount; i++) { SerializationTypes propOrField = (SerializationTypes) reader.ReadByte(); ElementTypes fieldType = (ElementTypes)reader.ReadByte(); ElementTypes arrayType = ElementTypes.END; switch (fieldType) { case ElementTypes.SZARRAY: { arrayType = (ElementTypes)reader.ReadByte(); if (arrayType == (ElementTypes)SerializationTypes.ENUM) { throw new Exception("Not implemented: Array of ENUM " + "for named field/property"); } break; } case (ElementTypes)SerializationTypes.ENUM: { String enumName = ExtractString(reader); if (enumName.Length == 0) { throw new Exception("Empty enum name"); } // Hope it is a 4-byte enum fieldType = (ElementTypes)SerializationTypes.U4; break; } case (ElementTypes)SerializationTypes.TAGGED_OBJECT: { throw new Exception("Not implemented: " + fieldType + " for named field/property"); } default: { break; } } String name = ExtractString(reader); Object value; if (fieldType == ElementTypes.SZARRAY) { value = ExtractArrayValue(arrayType, reader); } else { value = ExtractValue(fieldType, reader); } if (propOrField == SerializationTypes.FIELD || propOrField == SerializationTypes.PROPERTY) { this.namedArgs[i] = new NamedArg(propOrField == SerializationTypes.FIELD, -1, name, value); } else { throw new MetaDataLoader.IllegalMetaDataFormatException("Unknown prop-or-field type: " + propOrField); } } }
public void setPlayerElement(ElementTypes type) { _chosenPlayerElement = type; _chosenPlayerElementCount = Manager.TownManager.GetElementCountForCharacter(ControlledBy.Player); }
private static Object ExtractArrayValue(ElementTypes elementType, int arraySize, BinaryReader reader) { switch (elementType) { case ElementTypes.BOOLEAN: { bool[] array = new bool[arraySize]; for (int i = 0; i < arraySize; i++) { array[i] = reader.ReadBoolean(); } return(array); } case ElementTypes.CHAR: { char[] array = new char[arraySize]; for (int i = 0; i < arraySize; i++) { array[i] = (char)reader.ReadUInt16(); } return(array); } case ElementTypes.I1: { sbyte[] array = new sbyte[arraySize]; for (int i = 0; i < arraySize; i++) { array[i] = reader.ReadSByte(); } return(array); } case ElementTypes.U1: { byte[] array = new byte[arraySize]; for (int i = 0; i < arraySize; i++) { array[i] = reader.ReadByte(); } return(array); } case ElementTypes.I2: { short[] array = new short[arraySize]; for (int i = 0; i < arraySize; i++) { array[i] = reader.ReadInt16(); } return(array); } case ElementTypes.U2: { ushort[] array = new ushort[arraySize]; for (int i = 0; i < arraySize; i++) { array[i] = reader.ReadUInt16(); } return(array); } case ElementTypes.I4: { int[] array = new int[arraySize]; for (int i = 0; i < arraySize; i++) { array[i] = reader.ReadInt32(); } return(array); } case ElementTypes.U4: { uint[] array = new uint[arraySize]; for (int i = 0; i < arraySize; i++) { array[i] = reader.ReadUInt32(); } return(array); } case ElementTypes.I8: { long[] array = new long[arraySize]; for (int i = 0; i < arraySize; i++) { array[i] = reader.ReadInt64(); } return(array); } case ElementTypes.U8: { ulong[] array = new ulong[arraySize]; for (int i = 0; i < arraySize; i++) { array[i] = reader.ReadUInt64(); } return(array); } case ElementTypes.R4: { float[] array = new float[arraySize]; for (int i = 0; i < arraySize; i++) { array[i] = reader.ReadSingle(); } return(array); } case ElementTypes.R8: { double[] array = new double[arraySize]; for (int i = 0; i < arraySize; i++) { array[i] = reader.ReadDouble(); } return(array); } case ElementTypes.STRING: { String[] array = new String[arraySize]; for (int i = 0; i < arraySize; i++) { array[i] = ExtractString(reader); } return(array); } default: throw new Exception("Not implemented: custom attribute " + "array of type " + elementType); } }
public DOMElement(ElementTypes type, int startPosition) { Type = type; StartPosition = startPosition; }
public ActionResult DeleteElementType(Guid id) { bool result = ElementTypes.DeleteElementTypeByElementTypeId(id); return(RedirectToLocal("")); }
/// <summary> /// Get animations for current spellcast. /// This happens the first time a spell is cast and stored for re-casting. /// It's likely player will use a wide variety of spell types in normal play. /// </summary> void SetCurrentAnims(ElementTypes elementType, int border = 0, bool dilate = false) { // Attempt to get current anims if (castAnims.ContainsKey(elementType)) { currentAnimType = elementType; currentAnims = castAnims[elementType]; return; } // Load spellcast file string filename = WeaponBasics.GetMagicAnimFilename(elementType); string path = Path.Combine(DaggerfallUnity.Instance.Arena2Path, filename); CifRciFile cifFile = new CifRciFile(); if (!cifFile.Load(path, FileUsage.UseMemory, true)) { throw new Exception(string.Format("Could not load spell anims file {0}", path)); } // Load CIF palette cifFile.Palette.Load(Path.Combine(DaggerfallUnity.Instance.Arena2Path, cifFile.PaletteName)); // Load textures - spells have a single frame per record unlike weapons AnimationRecord[] animationRecords = new AnimationRecord[cifFile.RecordCount]; for (int record = 0; record < cifFile.RecordCount; record++) { Texture2D texture; if (!TextureReplacement.TryImportCifRci(filename, record, 0, false, out texture)) { // Get Color32 array DFSize sz; Color32[] colors = cifFile.GetColor32(record, 0, 0, border, out sz); // Dilate edges if (border > 0 && dilate) { ImageProcessing.DilateColors(ref colors, sz); } // Create Texture2D texture = new Texture2D(sz.Width, sz.Height, TextureFormat.ARGB32, false); texture.SetPixels32(colors); texture.Apply(true); } // Set filter mode and store in frames array if (texture) { texture.filterMode = (FilterMode)DaggerfallUnity.Settings.MainFilterMode; animationRecords[record].Texture = texture; animationRecords[record].Size = cifFile.GetSize(record); } } // Add frames array to dictionary castAnims.Add(elementType, animationRecords); // Use as current anims currentAnimType = elementType; currentAnims = animationRecords; }
private void Start() { // Setup light and shadows myLight = GetComponent <Light>(); myLight.enabled = EnableLight; forceDisableSpellLighting = !DaggerfallUnity.Settings.EnableSpellLighting; if (forceDisableSpellLighting) { myLight.enabled = false; } if (!DaggerfallUnity.Settings.EnableSpellShadows) { myLight.shadows = LightShadows.None; } initialRange = myLight.range; initialIntensity = myLight.intensity; // Setup collider myCollider = GetComponent <SphereCollider>(); myCollider.radius = ColliderRadius; // Setup rigidbody myRigidbody = GetComponent <Rigidbody>(); myRigidbody.useGravity = false; // Use payload when available if (payload != null) { // Set payload missile properties caster = payload.CasterEntityBehaviour; targetType = payload.Settings.TargetType; elementType = payload.Settings.ElementType; // Set spell billboard anims automatically from payload for mobile missiles if (targetType == TargetTypes.SingleTargetAtRange || targetType == TargetTypes.AreaAtRange) { UseSpellBillboardAnims(); } } // Setup senses if (caster && caster != GameManager.Instance.PlayerEntityBehaviour) { enemySenses = caster.GetComponent <EnemySenses>(); } // Setup arrow if (isArrow) { // Create and orient 3d arrow goModel = GameObjectHelper.CreateDaggerfallMeshGameObject(99800, transform); MeshCollider arrowCollider = goModel.GetComponent <MeshCollider>(); arrowCollider.sharedMesh = goModel.GetComponent <MeshFilter>().sharedMesh; arrowCollider.convex = true; arrowCollider.isTrigger = true; // Offset up so it comes from same place LOS check is done from Vector3 adjust; if (caster != GameManager.Instance.PlayerEntityBehaviour) { CharacterController controller = caster.transform.GetComponent <CharacterController>(); adjust = caster.transform.forward * 0.6f; adjust.y += controller.height / 3; } else { // Offset forward to avoid collision with player adjust = GameManager.Instance.MainCamera.transform.forward * 0.6f; // Adjust slightly downward to match bow animation adjust.y -= 0.11f; // Adjust to the right or left to match bow animation if (!GameManager.Instance.WeaponManager.ScreenWeapon.FlipHorizontal) { adjust += GameManager.Instance.MainCamera.transform.right * 0.15f; } else { adjust -= GameManager.Instance.MainCamera.transform.right * 0.15f; } } goModel.transform.localPosition = adjust; goModel.transform.rotation = Quaternion.LookRotation(GetAimDirection()); goModel.layer = gameObject.layer; } // Ignore missile collision with caster (this is a different check to AOE targets) if (caster) { Physics.IgnoreCollision(caster.GetComponent <Collider>(), this.GetComponent <Collider>()); } }
/// <summary> /// Checks if the entry at <paramref name="offset"/> in the <paramref name="signiture"/> /// heap is a token. /// </summary> /// <param name="signiture">The signiture to check.</param> /// <param name="offset">The offset in the signiture.</param> /// <returns>True if it is a token else false.</returns> public static bool IsToken(byte[] signiture, int offset) { ElementTypes type = (ElementTypes)GetCompressedValue(signiture, offset); return((type & ElementTypes.Pinned) != 0); }
public override void OnInspectorGUI() { // emptyTexture = (Texture)EditorGUIUtility.Load("Assets/EditorDefaultResources/empty.png"); base.OnInspectorGUI(); GUILayout.Label("Current Selected : " + currentSelected.ToString()); LevelCreator levelCreator = (LevelCreator)target; int rows = (int)Mathf.Sqrt(levelCreator.level.Count); //int currentI = levelCreator.level.Count-1; GUILayout.BeginVertical(); for (int r = rows - 1; r >= 0; r--) { GUILayout.BeginHorizontal(); for (int c = 0; c < rows; c++) { if (GUILayout.Button(textureHolder[levelCreator.level[c + ((rows) * r)]], GUILayout.Width(50), GUILayout.Height(50))) { levelCreator.level[c + ((rows) * r)] = currentSelected; } } GUILayout.EndHorizontal(); } GUILayout.EndVertical(); GUILayout.Space(20); GUILayout.BeginVertical(); GUILayout.BeginHorizontal(); int count = 0; foreach (KeyValuePair <ElementTypes, Texture> e in textureHolder) { count++; if (GUILayout.Button(e.Value, GUILayout.Width(50), GUILayout.Height(50))) { currentSelected = e.Key; } if (count % 4 == 0) { GUILayout.EndHorizontal(); GUILayout.BeginHorizontal(); } } GUILayout.EndVertical(); /* if (GUILayout.Button(textureHolder[ElementTypes.Empty],GUILayout.Width(50),GUILayout.Height(50))){ * currentSelected = ElementTypes.Empty; * } * else if (GUILayout.Button(textureHolder[ElementTypes.Baba], GUILayout.Width(50), GUILayout.Height(50))) * { * currentSelected = ElementTypes.Baba; * } * else if (GUILayout.Button(textureHolder[ElementTypes.Wall], GUILayout.Width(50), GUILayout.Height(50))) * { * currentSelected = ElementTypes.Wall; * } * else if (GUILayout.Button("Rock")) * { * currentSelected = ElementTypes.Rock; * } * else if (GUILayout.Button("Flag")) * { * currentSelected = ElementTypes.Flag; * } * else if (GUILayout.Button("Goop")) * { * currentSelected = ElementTypes.Goop; * } * else if (GUILayout.Button("Is")) * { * currentSelected = ElementTypes.IsWord; * } * else if (GUILayout.Button("BabaWord")) * { * currentSelected = ElementTypes.BabaWord; * } * else if (GUILayout.Button("WallWord")) * { * currentSelected = ElementTypes.WallWord; * } * else if (GUILayout.Button("FlagWord")) * { * currentSelected = ElementTypes.FlagWord; * } * else if (GUILayout.Button("RockWord")) * { * currentSelected = ElementTypes.RockWord; * } * else if (GUILayout.Button("YouWord")) * { * currentSelected = ElementTypes.YouWord; * } * else if (GUILayout.Button("PushWord")) * { * currentSelected = ElementTypes.PushWord; * } * else if (GUILayout.Button("WinWord")) * { * currentSelected = ElementTypes.WinWord; * } * else if (GUILayout.Button("StopWord")) * { * currentSelected = ElementTypes.StopWord; * }*/ }
public override State PushChar(char c, IParseContext context, ref string rollback) { if (context.CurrentStateLength == 1 && context.PreviousState is HtmlScriptBodyState) { return(Parent); } //NOTE: This is (mostly) duplicated in HtmlClosingTagState //handle "paragraph" tags implicitly closed by block-level elements if (context.CurrentStateLength == 1 && context.PreviousState is XmlNameState) { XElement element = (XElement)context.Nodes.Peek(); if (!element.Name.HasPrefix && element.Name.IsValid) { //Note: the node stack will always be at least 1 deep due to the XDocument var parent = context.Nodes.Peek(1) as XElement; while (parent != null && parent.ValidAndNoPrefix() && parent.IsImplicitlyClosedBy(element)) { context.Nodes.Pop(); context.Nodes.Pop(); if (warnAutoClose) { context.LogWarning(string.Format("Tag '{0}' implicitly closed by tag '{1}'.", parent.Name.Name, element.Name.Name), parent.Region); } //parent.Region.End = element.Region.Start; //parent.Region.EndColumn = Math.Max (parent.Region.EndColumn - 1, 1); parent.Close(parent); context.Nodes.Push(element); parent = context.Nodes.Peek(1) as XElement; } } } State ret = base.PushChar(c, context, ref rollback); if (ret == Parent && c == '>') { var element = context.Nodes.Peek() as XElement; if (element != null && !element.Name.HasPrefix && element.Name.IsValid) { if (element.Name.Name.Equals("script", StringComparison.OrdinalIgnoreCase)) { return(ScriptState); } else if (ElementTypes.IsEmpty(element.Name.Name)) { element.Close(element); context.Nodes.Pop(); if (warnAutoClose) { context.LogWarning(string.Format("Implicitly closed empty tag '{0}'", element.Name.Name), element.Region); } } } } return(ret); }
internal abstract void ChannelExitElement(ref ChannelInfos channelInfos, ElementTypes elementType);
public static String StringFromElementType(ElementTypes elementType) { return elementType.ToString(); }
internal override bool GetNextElementAs( ref Element e, bool AcceptChannelSection, string Name, L3TypeManager SupposedType, bool NeedsThisElement, bool WantClosingElement) { int?SupposedTypeNumber = SupposedType != null ? SupposedType.TypeIndex : (int?)null; if (!this.GetNextXmlPart()) { if (NeedsThisElement) { throw new Exception(); } else { return(false); // end of document. } } if (this.xmlReader.Name == XmlSerializationFormatter.DataEndMarkTag) { return(false); // end of document. } ElementTypes?et2 = this.GetElementType(); if (et2 == null) { #if DEBUG if (this.xmlReader.NodeType != XmlNodeType.EndElement && this.xmlReader.Name != "data") { Debugger.Break(); } #endif return(false); } ElementTypes et = et2.Value; if (WantClosingElement && this.xmlReader.NodeType == XmlNodeType.Element) { if (NeedsThisElement) { throw new Exception(); } else { return(false); } } #if DEBUG if (!AcceptChannelSection && !(et == ElementTypes.InstancesChannelSection || et == ElementTypes.TypesChannelSection)) { throw new Exception(); } // Checks name correspondance: string name = this.xmlReader.GetAttribute(XmlAttributeName.Name); if (Name != null && name != null && name != Name) { throw new Exception(); } #endif string typeNumber = this.xmlReader.GetAttribute(XmlAttributeName.TypeNumber); #if DEBUG // Checks type correspondance: if (typeNumber != null && typeNumber != string.Empty && SupposedTypeNumber != null) { int foundTypeNumber = int.Parse(typeNumber); if (foundTypeNumber != SupposedTypeNumber.Value) { var found = this.typeManagerCollection.GetTypeManager(foundTypeNumber); var foundGtd = found.l2TypeManager.L1TypeManager; if (!foundGtd.type.Is(typeof(ITypeContainer))) { var supposed = this.typeManagerCollection.GetTypeManager(SupposedTypeNumber.Value); var supposedGtd = supposed.l2TypeManager.L1TypeManager; if (!foundGtd.type.Is(supposedGtd.type)) { if (!supposedGtd.IsNullable || supposedGtd.type.GetGenericArguments().Length == 0 || !foundGtd.type.Is(supposedGtd.type.GetGenericArguments()[0])) { throw new Exception(); } } } } } #endif int?tn = typeNumber != null ? ( int.Parse(typeNumber)) : SupposedTypeNumber; string inum = this.xmlReader.GetAttribute(XmlAttributeName.InstanceIndex); int?InstanceNumber = inum != null? int.Parse(inum) : (int?)null; string noe = this.xmlReader.GetAttribute(XmlAttributeName.NumberOfElements); long?numberOfElements = noe != null? long.Parse(noe) : (long?)null; e.ContainsAValue = !this.xmlReader.IsEmptyElement; e.ElementType = et; e.InstanceIndex = InstanceNumber; e.IsAClosingTag = this.xmlReader.NodeType == XmlNodeType.EndElement; #if DEBUG e.Name = name != null ? name : Name; #endif e.NeedsAnEndElement = !this.xmlReader.IsEmptyElement; e.NumberOfElements = numberOfElements; if (tn != null) { e.typeIndex = tn.Value; e.typeIndexIsKnown = true; } return(true); }
Texture2D GetSpellElementIcon(ElementTypes elementType) { return(DaggerfallUI.Instance.SpellIconCollection.GetSpellElementIcon(elementType)); }
public void AddElementType(PlyElementType elementType) { ElementTypes.Add(elementType.Name, elementType); }
// -------------------------------------------- internal override void ChannelExitElement(ref ChannelInfos channelInfos, ElementTypes elementType) { this.ChannelWriteStringToStream( ref channelInfos, "</" + XmlSerializationFormatter.XmlElementNames[(int)elementType] + ">\n"); }
public bool Contains(ElementTypes element) { return(_elementTypes.ContainsKey(element)); }
// -------------------------------------------- internal override void ChannelExitElement(ref ChannelInfos channelInfos, ElementTypes elementType) { this.ChannelWriteStringToStream(ref channelInfos, "\n}"); }
public void Add(ElementTypes elementType, XElement element) { _elementTypes.Add(elementType, element); }
// -------------------------------------------- internal override void ChannelExitElement(ref ChannelInfos channelInfos, ElementTypes elementType) { }
public XElement Get(ElementTypes element) { return(_elementTypes[element]); }
// useless in this formatter. internal override void PassClosingTag(ElementTypes ElementType) { }
private ACConfiguration BuildConfiguration(DoorControllerDescriptor[] doorControllers, DoorDescriptor[] doors, EventDescriptor[] eventDescriptors) { var elements = new List <ACElement>(); // Add element types elements.Add(ElementTypes.ServerType); elements.Add(ElementTypes.DoorControllerType); // Add event types elements.AddRange(EventTypes.ServerEventTypes); foreach (var eventDescriptor in eventDescriptors) { var acEventType = TypeConverter.ToACEventType(eventDescriptor, !_disabledEventTypes.Contains(eventDescriptor.EventId)); elements.Add(acEventType); } // Add state types elements.AddRange(StateTypes.ServerStateTypes); elements.AddRange(StateTypes.DoorStateTypes); // Add command types elements.AddRange(CommandTypes.DoorCommands); // Look up the all events, which can be fired on a door // OBS: In the Demo Access Control application, events with source "DoorController" are actually fired on the door. var doorEventTypeIds = eventDescriptors.Where(e => e.SourceType == "Door" || e.SourceType == "DoorController").Select(ed => ed.EventId.ToString()); elements.Add(ElementTypes.CreateDoorType(doorEventTypeIds)); // Look up the all events, which can be fired on an access point var apEventTypeIds = eventDescriptors.Where(ed => ed.SourceType == "AccessPoint").Select(ed => ed.EventId.ToString()); elements.Add(ElementTypes.CreateAccessPointType(apEventTypeIds)); // Add server element elements.Add(TypeConverter.CreateACServer(_client.ServerId, _systemProperties.Address)); // Add door controllers foreach (var doorController in doorControllers) { elements.Add(TypeConverter.ToACUnit(doorController)); } // Add doors and access points foreach (var door in doors) { door.Enabled = !_disabledDoors.Contains(door.DoorId); elements.AddRange(TypeConverter.ToACUnits(door)); } try { return(ACConfiguration.CreateACConfiguration(DateTime.UtcNow, elements)); } catch (ACConfigurationException ex) { ACUtil.Log(true, "DemoACPlugin.ConfigurationManager", "Error building configuration: " + ex.Message); return(null); } }
public ElementAttribute(int identifier, ElementTypes type, string description = null) : this(type, description) { ClassIdentifier = new ClassIdentifier(identifier); }
internal abstract void PassClosingTag(ElementTypes ElementType);
public ElementAttribute(ClassIdentifier identifier, ElementTypes type, string description = null) : this(type, description) { ClassIdentifier = identifier; }
public Node(ElementTypes type, long id) : base(type, id) { }
internal bool IsTypeAndAlive(ElementTypes Type, Point P) { if (Type == ElementTypes.PacPlayer || Type == ElementTypes.Ghost) { foreach (Element E in Players) { if (E.et == Type && E.IsAlive && E.Location.Equals(P)) { return true; } } } else { Element E = null; FastBoard.TryGetValue(P, out E); return E != null && E.et == Type && E.IsAlive == true; } //foreach (Element E in FindAt(P)) //{ // if (E.et == Type && E.IsAlive) // { // return true; // } //} return false; }
private void DetermineElementType() { if (Items.Count == 0) { ElementType = ElementTypes.None; return; } // If at list one item is builtin, the whole category considers as builtin. if (Items.Any(item => item.ElementType.HasFlag(ElementTypes.BuiltIn))) ElementType = ElementTypes.BuiltIn; else { // If some items come from package, the whole category considers as package. if (Items.Any(item => item.ElementType.HasFlag(ElementTypes.Packaged))) ElementType = ElementTypes.Packaged; else { if (Items.Any(item => item.ElementType.HasFlag(ElementTypes.ZeroTouch))) ElementType = ElementTypes.ZeroTouch; else if (Items.Any(item => item.ElementType.HasFlag(ElementTypes.CustomNode))) ElementType = ElementTypes.CustomNode; } } }
internal Element(int line, ElementTypes types, string value) { Line = line; ElementType = types; ElementCheck(value); }
//---------------------------------------------------------------------------------------------------- public void Parse(st line) { this.MarkdownLine = line; this.TreeLevel = this.CountHyphens(line); line = line.TruncateLeft(this.TreeLevel).Trim(); if (line.StartsWith("'", false)) { this.ElementName = ""; this.ElementType = ElementTypes.HtmlLiteral; line = line.TruncateLeft(1); if (line.EndsWith("'", false)) { line = line.TruncateRight(1); } this.InnerHtml = line.TheString; } else { this.ElementType = ElementTypes.ElementsHolder; if (line.Contains("html=", false)) { string tmpLine = ""; bool insideSingleQuote = false; for (int i = 0; i < line.Length(); i++) { string c = line.Substring(i, 1); if (c == "'") { insideSingleQuote = !insideSingleQuote; } if (c == " " && insideSingleQuote) { tmpLine += "(---[[[SPACE].].]---)"; } else { tmpLine += c; } } line.TheString = tmpLine; } var tokens = line.Split(" ", false); if (tokens[0].StartsWith("i", true)) { this.ElementType = ElementTypes.EmptyElementTag; this.ElementName = "input"; this.InputType = "text"; var inArr = tokens[0].Split(":", false); if (inArr.Length > 1) { switch (inArr[1].TheString) { case "": this.InputType = "text"; break; case "t": this.InputType = "text"; break; case "b": this.InputType = "button"; break; case "s": this.InputType = "submit"; break; case "c": this.InputType = "checkbox"; break; case "r": this.InputType = "radio"; break; case "f": this.InputType = "file"; break; case "h": this.InputType = "hidden"; break; default: this.InputType = inArr[1].TheString; break; } } } else { switch (tokens[0].TheString) { case "d": this.ElementName = "div"; break; case "s": this.ElementName = "span"; break; case "br": this.ElementName = "br"; this.ElementType = ElementTypes.EmptyElementTag; break; case "t": this.ElementName = "table"; break; case "tr": this.ElementName = "tr"; break; case "td": this.ElementName = "td"; break; default: this.ElementName = tokens[0].TheString; break; } } this.ClassesString = ""; for (int i = 1; i < tokens.Length; i++) { var token = tokens[i].Trim(); token = token.Replace("(---[[[SPACE].].]---)", " "); if (token.Length() > 0) { if (token.StartsWith("#", false)) { this.IdClass = token.TruncateLeft(1).Trim().TheString; } else if (token.StartsWith(".", true)) { this.ClassesString += " " + token.TruncateLeft(1).Replace(".", " ").TheString; } else if (token.StartsWith("evt.", true)) { if (this.EventNames == null) { this.EventNames = new string[0]; } this.EventNames[this.EventNames.Length] = token.TruncateLeft(4).Trim().TheString; } else if (token.StartsWith("m=", true)) { var modelKey = token.TruncateLeft(2).Trim(); if (modelKey.StartsWith("'", false)) { modelKey = modelKey.TruncateLeft(1); } if (modelKey.EndsWith("'", false)) { modelKey = modelKey.TruncateRight(1); } this.ModelKey = modelKey.TheString; } else if (token.StartsWith("html=", true)) { var html = token.TruncateLeft(5).Trim(); if (html.StartsWith("'", false)) { html = html.TruncateLeft(1); } if (html.EndsWith("'", false)) { html = html.TruncateRight(1); } this.InnerHtml = html.TheString; } else if (token.StartsWith("v=", true)) { var value = token.TruncateLeft(2).Trim(); if (value.StartsWith("'", false)) { value = value.TruncateLeft(1); } if (value.EndsWith("'", false)) { value = value.TruncateRight(1); } this.Value = value.TheString; } else if (token.Contains("=", false)) { this.AttributesStr += " " + token.TheString + " "; } } } if (this.IdClass.Length > 0) { this.ClassesString += " " + this.IdClass; } this.ClassesString = st.New(this.ClassesString).Trim().TheString; if (this.EventNames != null && this.IdClass.Length > 0) { for (int i = 0; i < this.EventNames.Length; i++) { this.AttributesStr += st.New(" On_{0}='{1}_{0}'").Format2(this.EventNames[0], this.IdClass).TheString; } } } }
//---------------------------------------------------------------------------------------------------- public string ToHtmlString() { string rtn = ""; if (this.ElementType == ElementTypes.ElementsHolder && (this.Children == null || this.Children.Length < 0)) { this.ElementType = ElementTypes.HtmlHolder; } string prefix = ""; for (int i = 1; i < this.TreeLevel; i++) { prefix += " "; } string suffix = "\n"; if (1 != 0) { prefix = ""; suffix = ""; } st attributesStr = st.New(""); if (this.InputType.Length > 0) { attributesStr.AppendST(st.New(" type='{0}'").Format1(this.InputType)); } if (this.ModelKey.Length > 0) { attributesStr.AppendST(st.New(" ModelKey='{0}'").Format1(this.ModelKey)); } if (this.IdClass.Length > 0) { attributesStr.AppendST(st.New(" IdClass='{0}'").Format1(this.IdClass)); } if (this.ClassesString.Length > 0) { attributesStr.AppendST(st.New(" class='{0}'").Format1(this.ClassesString)); } if (this.Value.Length > 0) { attributesStr.AppendST(st.New(" value='{0}'").Format1(this.Value)); } attributesStr = attributesStr.Trim(); if (this.AttributesStr != "") { attributesStr.Append(" " + this.AttributesStr); } if (attributesStr.Length() > 0) { attributesStr.TheString = " " + attributesStr.TheString; } if (this.ElementType == ElementTypes.ElementsHolder) { rtn += st.New("{0}<{1}{2}>{3}").Format4(prefix, this.ElementName, attributesStr.TheString, suffix).TheString; for (int i = 0; i < this.Children.Length; i++) { rtn += this.Children[i].ToHtmlString(); } rtn += st.New("{0}</{1}>{2}").Format3(prefix, this.ElementName, suffix).TheString; } else if (this.ElementType == ElementTypes.HtmlHolder) { rtn += st.New("{0}<{1}{2}>{3}</{1}>{4}").Format5(prefix, this.ElementName, attributesStr.TheString, this.InnerHtml, suffix).TheString; } else if (this.ElementType == ElementTypes.EmptyElementTag) { rtn += st.New("{0}<{1}{2} />{3}").Format4(prefix, this.ElementName, attributesStr.TheString, suffix).TheString; } else if (this.ElementType == ElementTypes.HtmlLiteral) { rtn += st.New("{0}{1}{2}").Format3(prefix, this.InnerHtml, suffix).TheString; } return(rtn); }
private void BuildPath(InstructionSet IS, ElementTypes Type, Node Start) { //AlreadySearched.Add(this); //Random rnd = new Random(); //for (int i = IS.Last.Paths.Count; i > 1; i--) //{ // int pos = rnd.Next(i); // var x = IS.Last.Paths[i - 1]; // IS.Last.Paths[i - 1] = IS.Last.Paths[pos]; // IS.Last.Paths[pos] = x; //} //for (int i = 0; i < IS.Last.Paths.Count; i++ ) //{ // Path Path = IS.Last.Paths[i]; // if (Path.ContainsType(Type, Board) && (Shortest == null || Shortest.distance > IS.distance)) // { // Shortest = IS.AddPath(Path); // continue; // } // if (AlreadySearched.Contains(Path.End)) // { // continue; // } // Path.End.BuildPath(IS.AddPath(Path), Type); //} //AlreadySearched.Remove(this); Queue<Node> State = new Queue<Node>(); List<Node> Traveled = new List<Node>(); Queue<InstructionSet> Instructions = new Queue<InstructionSet>(); Traveled.Add(Start); State.Enqueue(Start); Instructions.Enqueue(IS); while (State.Count > 0) { Node T = State.Dequeue(); InstructionSet How = Instructions.Dequeue(); foreach (Path P in T.Paths) { if (P.ContainsType(Type, Board)) { InstructionSet Found = How.AddPath(P); if (Shortest == null || Found.distance < Shortest.distance) { Shortest = Found; } continue; } Node N = P.End; if (!Traveled.Contains(N)) { Traveled.Add(N); State.Enqueue(N); Instructions.Enqueue(How.AddPath(P)); } } } }