public void UpdateRing() { if (!double.IsNaN(Radius) && Radius > 0 && Center != null && PointCount > 2) { PointCollection pnts = new PointCollection(); for (int i = PointCount; i >= 0; i--) { double rad = 2 * Math.PI / PointCount * i; double x = Math.Cos(rad) * Radius + Center.X; double y = Math.Sin(rad) * Radius + Center.Y; pnts.Add(new MapPoint(x, y)); } if (Rings.Count == 0) { Rings.Add(pnts); } else { Rings[0] = pnts; } } else { Rings.Clear(); } }
private static bool RingsHaveDifferentIds( [NotNull] Dictionary <int, List <int> > pointIndexesById, [NotNull] Rings rings, out int firstPointId) { var errorRingsById = new Dictionary <int, List <IRing> >(); firstPointId = 0; bool first = true; foreach (KeyValuePair <int, List <int> > pair in pointIndexesById) { int pointId = pair.Key; List <int> pointIndexes = pair.Value; if (first) { firstPointId = pointId; } first = false; List <IRing> errorRings = rings.GetRingsIfComplete(pointIndexes); if (errorRings == null) { errorRingsById = null; break; } errorRingsById.Add(pointId, errorRings); } return(errorRingsById != null); }
// Use this for initialization void Start() { scanButton.onClick.AddListener(OnScanClick); travelButton.onClick.AddListener(OnTravelClick); sat = UnityEngine.Object.FindObjectOfType <Satellite> (); audioManager = UnityEngine.Object.FindObjectOfType <AudioManager>(); rings = UnityEngine.Object.FindObjectOfType <Rings> (); }
internal Polygon(JObject obj) { var coordinates = obj.GetValue("coordinates").ToObject <double[][][]>(); Rings = AsReadOnlyCollection(coordinates .Select(r => (IList <Point>)r.Select(p => new Point(p[0], p[1])).ToList()) .ToList()); _ringsWithOrderedPoints = Rings.Select(r => (IList <Point>)r.OrderBy(p => p).ToList()).ToList(); }
/// <summary> /// Creates a new instance of <see cref="Polygon"/> using serialization information. /// </summary> protected Polygon(SerializationInfo info, StreamingContext context) { var coordinates = (double[][][])info.GetValue("coordinates", typeof(double[][][])); Rings = AsReadOnlyCollection(coordinates .Select(r => (IList <Point>)r.Select(p => new Point(p[0], p[1])).ToList()) .ToList()); _ringsWithOrderedPoints = Rings.Select(r => (IList <Point>)r.OrderBy(p => p).ToList()).ToList(); }
/// <summary> /// Creates a new instance of <see cref="Polygon"/> using multiple rings. /// </summary> /// <param name="rings">The polygon rings</param> public Polygon(IList <IList <Point> > rings) { if (rings == null) { throw new ArgumentNullException("rings"); } Rings = AsReadOnlyCollection(rings, r => AsReadOnlyCollection(r)); _ringsWithOrderedPoints = Rings.Select(r => (IList <Point>)r.OrderBy(p => p).ToList()).ToList(); }
public object Convert(object value, Type targetType, object parameter, CultureInfo culture) { if (value is Rings) { Rings mask = (Rings)parameter; this.target = (Rings)value; return((mask & this.target) != 0); } return(false); }
private void WipeMoleculeRings() { Rings.RemoveAll(); //first set all atoms to side chains foreach (var a in Atoms) { a.Rings.RemoveAll(); _sortedRings = null; } }
/// <summary> /// Returns Well-known text (WKT) representation of the geometry object. /// </summary> public override string ToString() { if (Rings.Count == 0) { return("POLYGON EMPTY"); } return(string.Format("POLYGON ({0})", string.Join(", ", Rings.Select(r => "(" + string.Join(", ", r.Select(p => p.X.ToString(CultureInfo.InvariantCulture) + " " + p.Y.ToString(CultureInfo.InvariantCulture))) + ")")))); }
public RingTreeNode(Rings ringValue) { _ringValue = ringValue; Type ringType = typeof(Rings); Type infoType = typeof(RingInfoAttribute); RingInfoAttribute attr = ringType.GetMember(ringValue.ToString())[0].GetCustomAttributes(infoType, false) .Cast <RingInfoAttribute>().SingleOrDefault(); _name = attr.Name; _description = attr.Description; }
private int ReportPointErrors( [NotNull] IDictionary <int, List <int> > pointIndexesById, int maxPointsId, [NotNull] Rings rings, [NotNull] IRow row) { object missing = Type.Missing; IPointCollection points = new MultipointClass(); GeometryUtils.EnsureSpatialReference((IGeometry)points, rings.SpatialReference); foreach (KeyValuePair <int, List <int> > pair in pointIndexesById) { int id = pair.Key; if (id == maxPointsId) { continue; } List <int> pointIndexes = pair.Value; foreach (int pointIndex in pointIndexes) { IPoint point = rings.get_Point(pointIndex); points.AddPoint(point, ref missing, ref missing); } } string description; if (rings.RingsCount > 1) { description = string.Format( "The point ids of these points differ from the most frequent point id {0} " + "({1} occurrences) in the rings (outer ring = {2}. patch in multipatch)", maxPointsId, pointIndexesById[maxPointsId].Count, rings.FirstPatchIndex + 1); } else { description = string.Format( "The point ids of these points differ from the most frequent point id {0} " + "({1} occurrences) in the ring ({2}. patch in Multipatch)", maxPointsId, pointIndexesById[maxPointsId].Count, rings.FirstPatchIndex + 1); } return(ReportError(description, (IGeometry)points, Codes[Code.DifferentIdInRing], TestUtils.GetShapeFieldName(row), row)); }
private int ReportError( [NotNull] Rings rings, [NotNull] IDictionary <int, List <int> > pointIndexesById, int maxPointsId, [NotNull] IRow row) { int totalPointCount = 0; int errorPointCount = 0; foreach (KeyValuePair <int, List <int> > pair in pointIndexesById) { int id = pair.Key; List <int> pointIndexes = pair.Value; totalPointCount += pointIndexes.Count; if (id == maxPointsId) { continue; } errorPointCount += pointIndexes.Count; } if (errorPointCount < 5 && errorPointCount * 2 < totalPointCount) { return(ReportPointErrors(pointIndexesById, maxPointsId, rings, row)); } string description; if (rings.RingsCount > 1) { description = string.Format( "{0} point ids differ from the most frequent point id {1} " + "({2} occurrences) in the rings (outer ring = {3}. patch in multipatch)", errorPointCount, maxPointsId, pointIndexesById[maxPointsId].Count, rings.FirstPatchIndex); } else { description = string.Format( "{0} point ids differ from the most frequent point id {1} " + "({2} occurrences) in the ring ({3}. patch in multipatch)", errorPointCount, maxPointsId, pointIndexesById[maxPointsId].Count, rings.FirstPatchIndex); } return(ReportError(description, rings.CreateMultiPatch(), Codes[Code.DifferentIdInRing], TestUtils.GetShapeFieldName(row), row)); }
}//have we calculated the rings yet? public void RebuildRings() { #if DEBUG Stopwatch sw = new Stopwatch(); sw.Start(); #endif if (HasRings) { WipeMoleculeRings(); //working set of atoms //it's a dictionary, because we initially store the degree of each atom against it //this will change as the pruning operation kicks in Dictionary <Atom, int> workingSet = Projection(a => a.Degree); //lop off any terminal branches PruneSideChains(workingSet); while (workingSet.Any()) //do we have any atoms left in the set { var startAtom = workingSet.Keys.OrderByDescending(a => a.Degree).First(); // go for the highest degree atom Ring nextRing = GetRing(startAtom); //identify a ring if (nextRing != null) //bingo { //and add the ring to the atoms Rings.Add(nextRing); //add the ring to the set foreach (Atom a in nextRing.Atoms.ToList()) { if (!a.Rings.Contains(nextRing)) { a.Rings.Add(nextRing); } if (workingSet.ContainsKey(a)) { workingSet.Remove(a); } //remove the atoms in the ring from the working set BUT NOT the graph! } } else { workingSet.Remove(startAtom); } //the atom doesn't belong in a ring, remove it from the set. } } #if DEBUG //Debug.WriteLine($"Molecule = {(ChemicalNames.Count > 0 ? this.ChemicalNames?[0].Name : this.ConciseFormula)}, Number of rings = {Rings.Count}"); sw.Stop(); Debug.WriteLine($"Elapsed {sw.ElapsedMilliseconds}"); #endif }
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) { bool?b = value as bool?; if (b == true) { this.target |= (Rings)parameter; } else { this.target ^= (Rings)parameter; } return(this.target); }
private string PolygonToWkt() { if (!(Rings?.Length > 0)) { return("POLYGON EMPTY"); } else if (Rings.Length == 1) { return(FormattableString.Invariant($"POLYGON({EsriJsonHelper.PointArrayToString(Rings[0])})")); } else { return(FormattableString.Invariant($"MULTIPOLYGON({string.Join(", ", Rings.Select(i => $"({EsriJsonHelper.PointArrayToString(i)})"))})")); } }
public void SetCurrentStance(string ring) { if (string.IsNullOrEmpty(ring)) { CurrentStance = ring; } else if (Rings.ContainsKey(ring)) { CurrentStance = ring; } else { throw new ArgumentException($"Changement de posture: Anneau en paramètre incorrect : {ring}"); } }
public static bool IsJewelery(string itemBase) { if (Belts.Contains(itemBase)) { return(true); } if (Amulets.Contains(itemBase)) { return(true); } if (Rings.Contains(itemBase)) { return(true); } return(false); }
/// <summary> /// Sorts a series of small rings ready for determining double bond placement /// see DOI: 10.1002/minf.201200171 /// Rendering molecular sketches for publication quality output /// Alex M Clark /// </summary> /// <returns>List of rings</returns> // ReSharper disable once InconsistentNaming public List <Ring> SortRingsForDBPlacement() { // Debug.Assert(HasRings); //no bloody point in running this unless it has rings Debug.Assert(RingsCalculated); //make sure that if the molecule contains rings that we have calculated them //1) All rings of sizes 6, 5, 7, 4 and 3 are discovered, in that order, and added to a list R. var R = Rings.Where(x => x.Priority > 0).OrderBy(x => x.Priority).ToList(); //Define B as an array of size equal to the number of atoms, where each value is equal to the number of times the atom occurs in any of the rings R Dictionary <Atom, int> B = new Dictionary <Atom, int>(); foreach (Atom atom in Atoms) { B[atom] = atom.Rings.Count; } //Define Q as an array of size equal to length of R, where each value is equal to sum of B[r], where r iterates over each of the atoms within the ring. Dictionary <Ring, int> Q = new Dictionary <Ring, int>(); foreach (Ring ring in R) { int sumBr = 0; foreach (Atom atom in ring.Atoms) { sumBr += B[atom]; } Q[ring] = sumBr; } //Perform a stable sort of the list of rings, R, so that those with the lowest values of Q are listed first. var R2 = R.OrderBy(r => Q[r]); //Define D as an array of size equal to length of R, where each value is equal to the number of double bonds within the corresponding ring Dictionary <Ring, int> D = new Dictionary <Ring, int>(); foreach (Ring ring in R2) { D[ring] = ring.Bonds.Count(b => b.OrderValue == 2); } //Perform a stable sort of the list of rings, R, so that those with highest values of D are listed first var R3 = R2.OrderByDescending(r => D[r]); return(R3.ToList()); }
/// <summary> /// indicates which side of bond to draw subsidiary double bond /// </summary> /// if bond order is not 2, returns null /// if bond is in single ring, vector points to centre of ring /// if bond is in cisoid bond (excluding hydrogens) points to area /// including both bonds /// if bond is in 3 rings vector is null /// /// this is not foolproof as we may need to make a benzene ring consistent /// <returns></returns> public Vector?GetPrettyCyclicDoubleBondVector() { Debug.Assert(Parent.RingsCalculated); Vector?vector = null; Ring theRing = PrimaryRing; List <Ring> ringList = Rings.Where(x => x.Priority > 0).OrderBy(x => x.Priority).ToList(); if (ringList.Any()) //no rings { Point?ringCentroid = theRing.Centroid; vector = ringCentroid - MidPoint; } return(vector); }
protected (int, int) CostOfFighting(string[] input) { var boss = ReadStats(input); var minCostForWinning = int.MaxValue; var maxCostForLosing = 0; foreach (var weapon in Weapons) { foreach (var armor in Armors) { foreach (var ring1 in Rings) { foreach (var ring2 in Rings.Where(r => r != ring1)) { var cost = weapon.Cost + armor.Cost + ring1.Cost + ring2.Cost; var you = new Stats { Hitpoints = 100, Damage = weapon.Damage + armor.Damage + ring1.Damage + ring2.Damage, Armor = weapon.Armor + armor.Armor + ring1.Armor + ring2.Armor }; if (YouWinFight(boss, you)) { if (cost < minCostForWinning) { minCostForWinning = cost; } } else { if (cost > maxCostForLosing) { maxCostForLosing = cost; } } } } } } return(minCostForWinning, maxCostForLosing); }
private void DrawRings() { int ringCounter = 0; foreach (List <Node> ring in Rings.Skip(1)) { double radius = Radius * ((ringCounter + 1.0) / (Rings.Count - 1.0)); RingCoordinates.Add(new List <Coordinate <Node> >()); double angle = 0; double incrementor = 2.0 * Math.PI / ring.Count; foreach (Node item in ring) { RingCoordinates[ringCounter].Add(new Coordinate <Node> { CoordinateX = CenterX + (radius * Math.Cos(angle)), CoordinateY = CenterY + (radius * Math.Sin(angle)), Item = item }); angle += incrementor; } ringCounter++; } }
private int ReportError( [NotNull] Rings rings, [NotNull] Dictionary <int, List <int> > pointIndexesById, [NotNull] IRow row) { int firstId; if (RingsHaveDifferentIds(pointIndexesById, rings, out firstId)) { int outerRingIds = firstId; string description = string.Format("Point ids within rings are constant, " + "but inner ring point ids differ from outer ring point ids ({0})" + "(outer ring = {1}. patch in multipatch)", outerRingIds, rings.FirstPatchIndex + 1); IGeometry errorGeometry = rings.CreateMultiPatch(); return(ReportError(description, errorGeometry, Codes[Code.InnerRingIdDifferentFromOuterRingId], TestUtils.GetShapeFieldName(row), row)); } int?maxPointsId = GetMaxPointsId(pointIndexesById); if (maxPointsId == null) { IGeometry errorGeometry = rings.CreateMultiPatch(); string description = string.Format( rings.RingsCount <= 1 ? "Different point ids exist in this ring ({0}. patch in multipatch)" : "Different point ids exist in these rings (out ring = {0}. patch in multipatch)", rings.FirstPatchIndex + 1); return(ReportError(description, errorGeometry, Codes[Code.DifferentIdInRing], TestUtils.GetShapeFieldName(row), row)); } return(ReportError(rings, pointIndexesById, maxPointsId.Value, row)); }
public Obstacle(Vector2 position, float radius) { // Get offset radius var radiusOffset = radius + 0.5f; // Get offset radius squared var radiusOffsetSquared = radiusOffset * radiusOffset; // Create ring radius var radiusRing = 0; // Get ring coordinate var coordinateRing = Converter.Coordinate(position); // Add coordinates while (true) { // Create found var found = false; // Get ring var ring = Rings.Get(radiusRing++); // Run through ring for (int i = 0; i < ring.Count; i++) { var coordinate = ring.GetCoordinate(coordinateRing, i); // Get distance squared var distanceSquared = (coordinate - position).sqrMagnitude; // Check if distance is within offset radius if (distanceSquared < radiusOffsetSquared) { // Add coordinate _coordinates.Add(coordinate); // Set found found = true; } } // Check if not found if (!found) { // Stop loop break; } } }
private static List <(int cost, int armor, int damage)> GetCombinations() { var combinations = new List <(int, int, int)>(); var count = 0; for (int weaponIndex = 0; weaponIndex < Weapons.Count(); weaponIndex++) { for (int gearIndex = 0; gearIndex < Gear.Count(); gearIndex++) { for (int firstRingIndex = 0; firstRingIndex < Rings.Count(); firstRingIndex++) { for (int secondRingIndex = firstRingIndex + 1; secondRingIndex < Rings.Count(); secondRingIndex++) { count++; var combination = GetCombinationStats(weaponIndex, gearIndex, firstRingIndex, secondRingIndex); combinations.Add(combination); } } } } return(combinations); }
public string DisplayString(int indent = 0, bool includefront = true, MaterialCommoditiesList historicmatlist = null, MaterialCommoditiesList currentmatlist = null) { string inds = new string(' ', indent); StringBuilder scanText = new StringBuilder(); scanText.Append(inds); if (includefront) { scanText.AppendFormat("{0} {1}\n\n", BodyName, IsEDSMBody ? " (EDSM)" : ""); if (IsStar) { scanText.AppendFormat(GetStarTypeName()); } else if (PlanetClass != null) { scanText.AppendFormat("{0}", PlanetClass); if (!PlanetClass.ToLower().Contains("gas")) { scanText.AppendFormat((Atmosphere == null || Atmosphere == String.Empty) ? ", No Atmosphere" : (", " + Atmosphere)); } } if (IsLandable) { scanText.AppendFormat(", Landable"); } scanText.AppendFormat("\n"); if (HasAtmosphericComposition) { scanText.Append("\n" + DisplayAtmosphere(2)); } if (HasPlanetaryComposition) { scanText.Append("\n" + DisplayComposition(2)); } if (HasPlanetaryComposition || HasAtmosphericComposition) { scanText.Append("\n\n"); } if (nAge.HasValue) { scanText.AppendFormat("Age: {0} million years\n", nAge.Value.ToString("N0")); } if (nStellarMass.HasValue) { scanText.AppendFormat("Solar Masses: {0:0.00}\n", nStellarMass.Value); } if (nMassEM.HasValue) { scanText.AppendFormat("Earth Masses: {0:0.0000}\n", nMassEM.Value); } if (nRadius.HasValue) { if (IsStar) { scanText.AppendFormat("Solar Radius: {0:0.00} Sols\n", (nRadius.Value / solarRadius_m)); } else { scanText.AppendFormat("Body Radius: {0:0.00}km\n", (nRadius.Value / 1000)); } } } if (nSurfaceTemperature.HasValue) { scanText.AppendFormat("Surface Temp: {0}K\n", nSurfaceTemperature.Value.ToString("N0")); } if (Luminosity != null) { scanText.AppendFormat("Luminosity: {0}\n", Luminosity); } if (nSurfaceGravity.HasValue) { scanText.AppendFormat("Gravity: {0:0.0}g\n", nSurfaceGravity.Value / oneGee_m_s2); } if (nSurfacePressure.HasValue && nSurfacePressure.Value > 0.00 && !PlanetClass.ToLower().Contains("gas")) { if (nSurfacePressure.Value > 1000) { scanText.AppendFormat("Surface Pressure: {0} Atmospheres\n", (nSurfacePressure.Value / oneAtmosphere_Pa).ToString("N2")); } else { { scanText.AppendFormat("Surface Pressure: {0} Pa\n", (nSurfacePressure.Value).ToString("N2")); } } } if (Volcanism != null) { scanText.AppendFormat("Volcanism: {0}\n", Volcanism == String.Empty ? "No Volcanism" : System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo. ToTitleCase(Volcanism.ToLower())); } if (DistanceFromArrivalLS > 0) { scanText.AppendFormat("Distance from Arrival Point {0:N1}ls\n", DistanceFromArrivalLS); } if (nOrbitalPeriod.HasValue && nOrbitalPeriod > 0) { scanText.AppendFormat("Orbital Period: {0} days\n", (nOrbitalPeriod.Value / oneDay_s).ToString("N1")); } if (nSemiMajorAxis.HasValue) { if (IsStar || nSemiMajorAxis.Value > oneAU_m / 10) { scanText.AppendFormat("Semi Major Axis: {0:0.00}AU\n", (nSemiMajorAxis.Value / oneAU_m)); } else { scanText.AppendFormat("Semi Major Axis: {0}km\n", (nSemiMajorAxis.Value / 1000).ToString("N1")); } } if (nEccentricity.HasValue) { scanText.AppendFormat("Orbital Eccentricity: {0:0.000}\n", nEccentricity.Value); } if (nOrbitalInclination.HasValue) { scanText.AppendFormat("Orbital Inclination: {0:0.000}°\n", nOrbitalInclination.Value); } if (nPeriapsis.HasValue) { scanText.AppendFormat("Arg Of Periapsis: {0:0.000}°\n", nPeriapsis.Value); } if (nAbsoluteMagnitude.HasValue) { scanText.AppendFormat("Absolute Magnitude: {0:0.00}\n", nAbsoluteMagnitude.Value); } if (nAxialTilt.HasValue) { scanText.AppendFormat("Axial tilt: {0:0.00}°\n", nAxialTilt.Value * 180.0 / Math.PI); } if (nRotationPeriod.HasValue) { scanText.AppendFormat("Rotation Period: {0} days\n", (nRotationPeriod.Value / oneDay_s).ToString("N1")); } if (nTidalLock.HasValue && nTidalLock.Value) { scanText.Append("Tidally locked\n"); } if (Terraformable) { scanText.Append("Candidate for terraforming\n"); } if (HasRings) { scanText.Append("\n"); if (IsStar) { scanText.AppendFormat("Belt{0}", Rings.Count() == 1 ? ":" : "s:"); for (int i = 0; i < Rings.Length; i++) { if (Rings[i].MassMT > (oneMoon_MT / 10000)) { scanText.Append("\n" + RingInformation(i, 1.0 / oneMoon_MT, " Moons")); } else { scanText.Append("\n" + RingInformation(i)); } } } else { scanText.AppendFormat("Ring{0}", Rings.Count() == 1 ? ":" : "s:"); for (int i = 0; i < Rings.Length; i++) { scanText.Append("\n" + RingInformation(i)); } } } if (HasMaterials) { scanText.Append("\n" + DisplayMaterials(2, historicmatlist, currentmatlist) + "\n"); } string habzonestring = HabZoneString(); if (habzonestring != null) { scanText.Append("\n" + habzonestring); } if (scanText.Length > 0 && scanText[scanText.Length - 1] == '\n') { scanText.Remove(scanText.Length - 1, 1); } if (EstimatedValue > 0) { scanText.AppendFormat("\nEstimated value: {0:N0}", EstimatedValue); } if (EDSMDiscoveryCommander != null) { scanText.AppendFormat("\n\nDiscovered by " + EDSMDiscoveryCommander + " on " + EDSMDiscoveryUTC.ToStringZulu()); } return(scanText.ToNullSafeString().Replace("\n", "\n" + inds)); }
/// <summary> /// Initializes a new instance of the <see cref="RingSecret"/> class with the /// specified <paramref name="gameId"/> and <paramref name="rings"/>. /// </summary> /// <param name="gameId">The game identifier.</param> /// <param name="rings">The rings.</param> public RingSecret(short gameId, Rings rings) { GameID = gameId; Rings = rings; }
public override void LoadContent() { Content = new ContentManager(ScreenManager.Game.Services, "Content"); SpriteBatch = ScreenManager.SpriteBatch; backgroundBatch = new SpriteBatch(ScreenManager.GraphicsDevice); bg = Content.Load<Texture2D>("Sprites/background"); mg = new MovingBackground(Content.Load<Texture2D>("Sprites/middleground"), ScreenManager.GraphicsDevice.Viewport, speed/2); fg = new MovingBackground(Content.Load<Texture2D>("Sprites/foreground"), ScreenManager.GraphicsDevice.Viewport, speed); plane = new Plane(Content.Load<Texture2D>("Sprites/plane"), Content.Load<SoundEffect>("Sound/plane")); ringFront = Content.Load<Texture2D>("Sprites/ringFront"); ringBack = Content.Load<Texture2D>("Sprites/ringBack"); ringFrontCleared = Content.Load<Texture2D>("Sprites/ringFrontCleared"); ringBackCleared = Content.Load<Texture2D>("Sprites/ringBackCleared"); ringSound = Content.Load<SoundEffect>("Sound/ringDoDoDo"); rings = new Rings(ringFront, ringBack, ringFrontCleared, ringBackCleared, numRings, speed, ScreenManager.GraphicsDevice.Viewport.Width, ScreenManager.GraphicsDevice.Viewport.Height, ringSound); gameFont = Content.Load<SpriteFont>("Font"); float scoreLength = (gameFont.MeasureString("999/999")).X; scorePosition = new Vector2(this.ScreenManager.ScaleXPosition((this.ScreenManager.GraphicsDevice.PresentationParameters.BackBufferWidth / 2.0f) - (scoreLength / 2.0f)), this.ScreenManager.ScaleYPosition(20.0f)); plane.playSound(); }
/// <summary> /// is the bond cyclic /// </summary> /// <returns>bool indicating cyclicity</returns> public bool IsCyclic() { return(Rings.Any()); }
public void LoadFromRow(DataRow row) { try { ID = Convert.ToInt32(row["JudgeID"]); UserID = Convert.ToInt32(row["UserID"]); _Notes = row["Notes"].ToString(); if (row.Table.Columns.Contains("Status")) _Status = (JudgeStatus)Convert.ToInt32(row["Status"]); if (row.Table.Columns.Contains("JudgeName")) JudgeName = Convert.ToString(row["JudgeName"]); if (row.Table.Columns.Contains("Allocated")) _Allocated = Convert.ToInt32(row["Allocated"]); if (row.Table.Columns.Contains("RingID")) _ringID = Convert.ToInt32(row["RingID"]); if (row.Table.Columns.Contains("ShowDetailsID") && row["ShowDetailsID"] != DBNull.Value) { ShowDetailsID = Convert.ToInt32(row["ShowDetailsID"]); } if (row.Table.Columns.Contains("ShowDate") && row["ShowDate"] != DBNull.Value) { ShowDate = Convert.ToDateTime(row["ShowDate"]); } if (row.Table.Columns.Contains("RingOrder")) { RingOrder = Convert.ToInt32(row["RingOrder"]); } _user = new User(UserID); _ring = new Rings(_ringID); } catch (Exception e ) { AppException.LogEvent("Judge.LoadFromRow:" + e.Message); } }
public void rings() { Rings rings1 = new Rings(); rings1.rings(); }
/// <summary> /// Loads in data from the specified game info /// </summary> /// <param name="info">The game info</param> /// <example> /// <code language="C#"> /// GameInfo info = new GameInfo() /// { /// GameID = 14129, /// Rings = Rings.PowerRingL1 | Rings.DoubleEdgeRing | Rings.ProtectionRing /// }; /// RingSecret secret = new RingSecret(); /// secret.Load(info); /// </code> /// </example> public override void Load(GameInfo info) { GameID = info.GameID; Rings = info.Rings; }
public static string GetItemType(string itemBase) { if (Bows.Contains(itemBase)) { return("Bow"); } if (Claws.Contains(itemBase)) { return("Claw"); } if (OneHandedAxes.Contains(itemBase)) { return("One Hand Axe"); } if (OneHandedMaces.Contains(itemBase)) { return("One Hand Mace"); } if (OneHandedSwords.Contains(itemBase)) { return("One Hand Sword"); } if (TwoHandedAxes.Contains(itemBase)) { return("Two Hand Axe"); } if (TwoHandedMaces.Contains(itemBase)) { return("Two Hand Mace"); } if (Sceptres.Contains(itemBase)) { return("Sceptre"); } if (Daggers.Contains(itemBase)) { return("Dagger"); } if (Staves.Contains(itemBase)) { return("Staff"); } if (Belts.Contains(itemBase)) { return("Belt"); } if (Amulets.Contains(itemBase)) { return("Amulet"); } if (Rings.Contains(itemBase)) { return("Ring"); } if (Boots.Contains(itemBase)) { return("Boots"); } if (Gloves.Contains(itemBase)) { return("Gloves"); } if (BodyArmors.Contains(itemBase)) { return("Body Armour"); } if (Wands.Contains(itemBase)) { return("Wand"); } if (Helmets.Contains(itemBase)) { return("Helmet"); } if (Shields.Contains(itemBase)) { return("Shield"); } if (Jewels.Contains(itemBase)) { return("Jewel"); } if (itemBase == "Gem") { return(itemBase); } if (Quivers.Contains(itemBase)) { return("Quiver"); } return("No type found"); }