public ProjectileSkill(
string name, int reqStr, int reqAgi, int reqInt,
Tier tier, int manaCost, string directory, int projectileSpeed)
: base(name, reqStr, reqAgi, reqInt, tier, manaCost)
{
this.ProjectileSpeed = projectileSpeed;
this.Directory = directory;
}
public TranslationJob(string slug, string textToTranslate, string sourceLanguageCode, string targetLanguageCode, Tier tier)
{
this.TextToTranslate = textToTranslate;
this.SourceLanguageCode = sourceLanguageCode;
this.TargetLanguageCode = targetLanguageCode;
this.Tier = tier;
this.Slug = slug;
}
protected Skill(string name, int reqStr, int reqAgi, int reqInt, Tier tier, int manaCost)
{
this.Name = name;
this.RequiredStrength = reqStr;
this.RequiredAgility = reqAgi;
this.RequiredIntelligence = reqInt;
this.Tier = tier;
this.ManaCost = manaCost;
}
private string GetTierName(Tier tier)
{
switch (tier)
{
case Tier.Application:
return "application";
case Tier.Database:
return "database";
case Tier.Web:
return "web";
default:
throw new ConDepInvalidEnumValueException(tier);
}
}
public MaterialsView(BohemianArtifact bbshelf, Vector3 position, Vector3 size)
{
bookshelf = bbshelf;
bookshelf.Library.SelectedArtifactChanged += new ArtifactLibrary.SelectedArtifactHandler(library_SelectedArtifactChanged);
this.position = position;
this.size = size;
titleText = new SelectableText(XNA.Font, "Materials", new Vector3(0.4f, 0, 0), bookshelf.GlobalTextColor, Color.White);
titleText.InverseScale(0.8f, size.X, size.Y);
// create a list of tier boundaries
tierBoundaries = new Tier[MAX_TIERS];
tierBoundaries[0] = new Tier(0, 0.25f);
tierBoundaries[1] = new Tier(0.275f, 0.02f);
tierBoundaries[2] = new Tier(0.325f, 0.020f);
tierBoundaries[3] = new Tier(0.375f, 0.020f);
tierBoundaries[4] = new Tier(0.425f, 0.020f);
// and a list of materials that were previously selected
materialConstraints = new List<string>();
// and the list of tiers, including the center
materialTiers = new List<ArrayList>();
// the border circle that encases the centre and separates the tiers
borderCircle = new SelectableEllipse(new Vector2(center.X, center.Y), tierBoundaries[0].CircleRadius, 0.01f, Color.White, Color.Gray, null);
animationTimer = new Timer(0.5f);
animationTimer.FinishEvent += new TimerFinished(AnimationTimerFinished);
materialColors = new Dictionary<string, Color>();
materialTextures = new Dictionary<string, Texture2D>();
LoadMaterialTextures();
materialTexts = new Dictionary<string, SelectableText>();
LoadMaterialTexts();
CreateMaterialBlobs();
PackAllTiers();
animationTimer.Start();
}
public TierAttribute(Tier tier)
{
_tierName = GetTierName(tier);
}
public async Task <IOfferOperations> RemoteAsync(Tier tier, Action <IOfferRemoteOperations, ServerConfig> remote)
{
var servers = _settings.Config.Tiers.Single(x => x.Name.Equals(tier.ToString())).Servers;
return(await ExecuteRemoteAsync(remote, servers));
}
/// <summary>
/// Parameterized Constructor
/// </summary>
/// <param name="userId"></param>
/// <param name="tier"></param>
/// <param name="status"></param>
public UserTierLevelStatus(int userId, Tier tier, Status status)
{
UserId = userId;
Tier = tier;
Status = status;
}
public async Task <IEnumerable <LeagueEntry> > GetAllLeagues(Region region, Queue queue, Tier tier, Division division)
{
string response = await _networkClient.SendGetRequest(region, $"{ROOT_URL}{ENTRIES_BY_QUEUE_TIER_DIVISION}", queue, tier, division);
return(_deserializer.Deserialize <List <LeagueEntry> >(response));
}
public Task HistogramCommandAsync(LocationCode location, DivisionWithCategory div, Tier tier) => GenerateHistogramAsync(div, tier, null, location);
public Task HistogramCommandAsync(DivisionWithCategory div, Tier tier) => GenerateHistogramAsync(div, tier, null, null);
public Task HistogramCommandAsync(LocationCode location, Tier tier) => GenerateHistogramAsync(null, tier, null, location);
public Task GetTeamWithPercentileCommandAsync(
[Summary("The percentile rank, from 0 to 100, for which information should be displayed."), InclusiveRange(0, 100)] double rank,
[Summary("If provided, the division (and optionally category) within which the percentile will be calculated."), AlterParameterDisplay(DisplayAsOptional = true)] DivisionWithCategory division,
[Summary("If provided, the tier within which the percentile will be calculated."), AlterParameterDisplay(DisplayAsOptional = true, SubordinateTo = "division")] Tier tier) => GetTeamWithPercentileAsync(rank, division, tier);
public Task GetTeamWithRankCommandAsync(
[Summary("The placement to display. The team at this placement will be displayed. Must be inclusively between 1 and the number of teams.")] int rank,
[Summary("If provided, the location within which ranking should be calculated."), AlterParameterDisplay(DisplayAsOptional = true)] LocationCode location,
[Summary("If provided, the division (and optionally category) within which ranking should be calculated."), AlterParameterDisplay(DisplayAsOptional = true)] DivisionWithCategory division,
[Summary("If provided, the tier within which ranking should be calculated."), AlterParameterDisplay(DisplayAsOptional = true, SubordinateTo = "division")] Tier tier) => GetTeamWithRankAsync(rank, location, division, tier);
public Task GetTeamWithRankCommandAsync(int rank, DivisionWithCategory division, Tier tier) => GetTeamWithRankAsync(rank, null, division, tier);
private bool CanUpgradeTo(Tier tier)
{
var cost = GetCost(tier);
return(Player.Player.Resources.HasEnough(cost) && _assembly.GetComponents(tier).All(x => Player.Player.Unlocks.IsUnlocked(x.Identifier)));
}
private IResourceCost GetCost(Tier tier) => _assembly.GetCost(tier).Subtract(_assembly.GetCost(_assembly.CurrentTeir));
/// <summary>
/// Removes all elements in scope from the instance.
/// </summary>
/// <param name="theTier">The tier to remove the elements from.</param>
/// <param name="xMin">The min x-value of the scope.</param>
/// <param name="xMax">The max x-value of the scope.</param>
/// <param name="yMin">The min y-value of the scope.</param>
/// <param name="yMax">The max y-value of the scope.</param>
public void ModRemoveWaypoints(ITierInfo theTier, double xMin, double yMin, double xMax, double yMax)
{
Tier tier = theTier as Tier;
// Remove waypoints
List <Waypoint> remWaypoints = Waypoints.Where(w => w.Tier == tier && xMin <= w.X && w.X <= xMax && yMin <= w.Y && w.Y <= yMax).ToList();
// Remove all of them
foreach (var waypoint in remWaypoints)
{
// Remove the waypoint - the waypoint graph handles all cascading path removals
waypoint.Tier.RemoveWaypoint(waypoint);
// Remove all elements that were connected to the waypoint
foreach (var guard in Semaphores.SelectMany(s => s.Guards).Where(guard => guard.From == waypoint || guard.To == waypoint).ToArray())
{
guard.Semaphore.UnregisterGuard(guard);
if (guard.Semaphore.Guards.Count() == 0)
{
Semaphores.Remove(guard.Semaphore);
}
}
foreach (var station in InputStations.Where(s => s.Waypoint == waypoint).ToArray())
{
station.Tier.RemoveInputStation(station);
InputStations.Remove(station);
}
foreach (var station in OutputStations.Where(s => s.Waypoint == waypoint).ToArray())
{
station.Tier.RemoveOutputStation(station);
OutputStations.Remove(station);
}
foreach (var pod in Pods.Where(p => p.Waypoint == waypoint).ToArray())
{
pod.Tier.RemovePod(pod);
Pods.Remove(pod);
}
foreach (var elevator in Elevators.Where(e => e.ConnectedPoints.Contains(waypoint)))
{
elevator.UnregisterPoint(waypoint);
if (elevator.ConnectedPoints.Count == 0)
{
Elevators.Remove(elevator);
}
}
// Make sure it is not on the list of storage locations anymore
if (waypoint.PodStorageLocation)
{
ResourceManager.RemovePodStorageLocation(waypoint);
}
// Finally remove from the overall waypoint list
Waypoints.Remove(waypoint);
}
// Also remove movables in scope
List <Bot> remBots = Bots.Where(b => b.Tier == tier && xMin <= b.X && b.X <= xMax && yMin <= b.Y && b.Y <= yMax).ToList();
foreach (var bot in remBots)
{
Bots.Remove(bot);
bot.Tier.RemoveBot(bot);
}
List <Pod> remPods = Pods.Where(p => p.Tier == tier && xMin <= p.X && p.X <= xMax && yMin <= p.Y && p.Y <= yMax).ToList();
foreach (var pod in remPods)
{
Pods.Remove(pod);
pod.Tier.RemovePod(pod);
}
}
public Invalid_tier_details_exception(string message, Tier tier)
: base(message)
{
Tier = tier;
}
public Task HistogramCommandAsync(string imageName, Tier tier) => GenerateHistogramAsync(null, tier, imageName, null);
public Task GetLeaderboardAsync(Tier tier, int pageNumber = 1) => GetLeaderboardImplementationAsync(null, null, null, tier, pageNumber);
public Task HistogramCommandAsync(string imageName, LocationCode location, Tier tier) => GenerateHistogramAsync(null, tier, imageName, location);
public Task GetLeaderboardAsync(LocationCode location, Tier tier, int pageNumber = 1) => GetLeaderboardImplementationAsync(location, null, null, tier, pageNumber);
public Task HistogramCommandAsync(string imageName, DivisionWithCategory div, Tier tier) => GenerateHistogramAsync(div, tier, imageName, null);
public Task GetLeaderboardAsync(DivisionWithCategory division, Tier tier, int pageNumber = 1) => GetLeaderboardImplementationAsync(null, division.Category, division.Division, tier, pageNumber);
public Task HistogramCommandAsync(
[Summary("The exact name of the image for which scores should be retrieved. If unspecified, total scores will be used. Only supported on offline score parameters. See the `datasource` command."), AlterParameterDisplay(DisplayAsOptional = true)] string imageName,
[Summary("The location (either two-letter postal code or three-letter country code, in all caps) to filter the analysis to, if provided."), AlterParameterDisplay(DisplayAsOptional = true)] LocationCode location,
[Summary("The division (and optionally category) to filter the analysis to, if provided."), AlterParameterDisplay(DisplayAsOptional = true)] DivisionWithCategory div,
[Summary("The tier to filter the analysis to, if provided."), AlterParameterDisplay(DisplayAsOptional = true)] Tier tier
) => GenerateHistogramAsync(div, tier, imageName, location);
public Task GetLeaderboardAsync(
[Summary("The location to which scoreboard display should be filtered, if provided."), AlterParameterDisplay(DisplayAsOptional = true)] LocationCode location,
[Summary("The division (and optionally category) to which scoreboard display should be filtered, if provided."), AlterParameterDisplay(DisplayAsOptional = true)] DivisionWithCategory division,
[Summary("The tier to which scoreboard display should be filtered, if provided."), AlterParameterDisplay(DisplayAsOptional = true)] Tier tier,
int pageNumber = 1) => GetLeaderboardImplementationAsync(location, division.Category, division.Division, tier, pageNumber);
public static int GetGoal(this TieredAchievement achievement, Tier tier)
{
switch (achievement)
{
case TieredAchievement.ReachedGoal:
switch (tier)
{
case Tier.Bronze:
return(5);
case Tier.Silver:
return(15);
case Tier.Gold:
return(30);
case Tier.Complete:
return(int.MaxValue);
default:
#if DEBUG
throw new ArgumentOutOfRangeException(nameof(tier), tier, null);
#else
return(int.MaxValue);
#endif
}
case TieredAchievement.ThirtyMinutes:
switch (tier)
{
case Tier.Bronze:
return(5);
case Tier.Silver:
return(15);
case Tier.Gold:
return(30);
case Tier.Complete:
return(int.MaxValue);
default:
#if DEBUG
throw new ArgumentOutOfRangeException(nameof(tier), tier, null);
#else
return(int.MaxValue);
#endif
}
case TieredAchievement.ReachedGoalFiveDaysInARow:
switch (tier)
{
case Tier.Bronze:
return(1);
case Tier.Silver:
return(3);
case Tier.Gold:
return(6);
case Tier.Complete:
return(int.MaxValue);
default:
#if DEBUG
throw new ArgumentOutOfRangeException(nameof(tier), tier, null);
#else
return(int.MaxValue);
#endif
}
default:
#if DEBUG
throw new ArgumentOutOfRangeException(nameof(achievement), achievement, null);
#else
return(int.MaxValue);
#endif
}
}
public Task GetImageLeaderboardAsync(string imageName, LocationCode location, Tier tier, int pageNumber = 1) => GetImageLeaderboardImplementationAsync(imageName, location, null, null, tier, pageNumber);
/// <summary>
/// GenerateReport
///
/// This routine takes a feature layer that references a feature class that participates in a utility network.
/// It returns a set of data to display on the UI thread.
///
///
/// </summary>
public LoadTraceResults GenerateReport(Layer selectedLayer)
{
// Create a new results object. We use this class to pass back a set of data from the worker thread to the UI thread
LoadTraceResults results = new LoadTraceResults();
// Initialize a number of geodatabase objects
using (UtilityNetwork utilityNetwork = UtilityNetworkUtils.GetUtilityNetworkFromLayer(selectedLayer))
{
if (utilityNetwork == null)
{
results.Message = "Please select a utility network layer.";
results.Success = false;
}
else if (!ValidateDataModel(utilityNetwork))
{
results.Message = "This sample is designed for a different utility network data model";
results.Success = false;
}
else
{
using (Geodatabase utilityNetworkGeodatabase = utilityNetwork.GetDatastore() as Geodatabase)
using (UtilityNetworkDefinition utilityNetworkDefinition = utilityNetwork.GetDefinition())
using (Geodatabase defaultGeodatabase = new Geodatabase(new FileGeodatabaseConnectionPath(new Uri(Project.Current.DefaultGeodatabasePath))))
using (TraceManager traceManager = utilityNetwork.GetTraceManager())
{
// Get a row from the starting points table in the default project workspace. This table is created the first time the user creates a starting point
// If the table is missing or empty, a null row is returned
using (Row startingPointRow = GetStartingPointRow(defaultGeodatabase, ref results))
{
if (startingPointRow != null)
{
// Convert starting point row into network element
Element startingPointElement = GetElementFromPointRow(startingPointRow, utilityNetwork, utilityNetworkDefinition);
// Obtain a tracer object
DownstreamTracer downstreamTracer = traceManager.GetTracer <DownstreamTracer>();
// Get the network attributes that we will use in our trace
using (NetworkAttribute phasesNetworkAttribute = utilityNetworkDefinition.GetNetworkAttribute(PhaseAttributeName))
using (NetworkAttribute loadNetworkAttribute = utilityNetworkDefinition.GetNetworkAttribute(LoadAttributeName))
{
if (phasesNetworkAttribute == null || loadNetworkAttribute == null)
{
results.Success = false;
results.Message = "This add-in requires network attributes for phase, service load, and device status.\n";
return(results);
}
// Get the Domain Network and Medium Voltage Tier
DomainNetwork electricDomainNetwork = utilityNetworkDefinition.GetDomainNetwork(ElectricDomainNetwork);
Tier mediumVoltageTier = electricDomainNetwork.GetTier(MediumVoltageTier);
// Set up the trace configuration
TraceConfiguration traceConfiguration = new TraceConfiguration();
// Configure the trace to use the electric domain network
traceConfiguration.DomainNetwork = electricDomainNetwork;
// Take the default TraceConfiguration from the Tier for Traversability
Traversability tierTraceTraversability = mediumVoltageTier.TraceConfiguration.Traversability;
traceConfiguration.Traversability.FunctionBarriers = tierTraceTraversability.FunctionBarriers;
traceConfiguration.Traversability.Scope = tierTraceTraversability.Scope;
ConditionalExpression baseCondition = tierTraceTraversability.Barriers as ConditionalExpression;
// Set to false to ensure that ServicePoints with incorrect phasing (which therefore act as barriers)
// are not counted with results
traceConfiguration.IncludeBarriersWithResults = false;
// Create a condition to only return features that have the service point category
ConditionalExpression servicePointCategoryCondition = new CategoryComparison(CategoryOperator.IsEqual, ServicePointCategory);
// Create function to sum loads on service points where phase = A
ConditionalExpression aPhaseCondition = new NetworkAttributeComparison(phasesNetworkAttribute, Operator.DoesNotIncludeTheValues, APhase);
Add aPhaseLoad = new Add(loadNetworkAttribute, servicePointCategoryCondition);
// Create function to sum loads on service points where phase = B
ConditionalExpression bPhaseCondition = new NetworkAttributeComparison(phasesNetworkAttribute, Operator.DoesNotIncludeTheValues, BPhase);
Add bPhaseLoad = new Add(loadNetworkAttribute, servicePointCategoryCondition);
// Create function to sum loads on service points where phase = C
ConditionalExpression cPhaseCondition = new NetworkAttributeComparison(phasesNetworkAttribute, Operator.DoesNotIncludeTheValues, CPhase);
Add cPhaseLoad = new Add(loadNetworkAttribute, servicePointCategoryCondition);
// Set the output condition to only return features that have the service point category
traceConfiguration.OutputCondition = servicePointCategoryCondition;
// Create starting point list and trace argument object
List <Element> startingPointList = new List <Element>()
{
startingPointElement
};
TraceArgument traceArgument = new TraceArgument(startingPointList);
traceArgument.Configuration = traceConfiguration;
// Trace on the A phase
traceConfiguration.Traversability.Barriers = new Or(baseCondition, aPhaseCondition);
traceConfiguration.Functions = new List <Function>()
{
aPhaseLoad
};
traceArgument.Configuration = traceConfiguration;
try
{
IReadOnlyList <Result> resultsA = downstreamTracer.Trace(traceArgument);
ElementResult elementResult = resultsA.OfType <ElementResult>().First();
results.NumberServicePointsA = elementResult.Elements.Count;
FunctionOutputResult functionOutputResult = resultsA.OfType <FunctionOutputResult>().First();
results.TotalLoadA = (double)functionOutputResult.FunctionOutputs.First().Value;
}
catch (ArcGIS.Core.Data.GeodatabaseUtilityNetworkException e)
{
//No A phase connectivity to source
if (!e.Message.Equals("No subnetwork source was discovered."))
{
results.Success = false;
results.Message += "No Subnetwork source was discovered for Phase A.\n";
}
}
// Trace on the B phase
traceConfiguration.Traversability.Barriers = new Or(baseCondition, bPhaseCondition);
traceConfiguration.Functions = new List <Function>()
{
bPhaseLoad
};
traceArgument.Configuration = traceConfiguration;
try
{
IReadOnlyList <Result> resultsB = downstreamTracer.Trace(traceArgument);
ElementResult elementResult = resultsB.OfType <ElementResult>().First();
results.NumberServicePointsB = elementResult.Elements.Count;
FunctionOutputResult functionOutputResult = resultsB.OfType <FunctionOutputResult>().First();
results.TotalLoadB = (double)functionOutputResult.FunctionOutputs.First().Value;
}
catch (ArcGIS.Core.Data.GeodatabaseUtilityNetworkException e)
{
// No B phase connectivity to source
if (!e.Message.Equals("No subnetwork source was discovered."))
{
results.Success = false;
results.Message += "No Subnetwork source was discovered for Phase B.\n";
}
}
// Trace on the C phase
traceConfiguration.Traversability.Barriers = new Or(baseCondition, cPhaseCondition);
traceConfiguration.Functions = new List <Function>()
{
cPhaseLoad
};
traceArgument.Configuration = traceConfiguration;
try
{
IReadOnlyList <Result> resultsC = downstreamTracer.Trace(traceArgument);
ElementResult elementResult = resultsC.OfType <ElementResult>().First();
results.NumberServicePointsC = elementResult.Elements.Count;
FunctionOutputResult functionOutputResult = resultsC.OfType <FunctionOutputResult>().First();
results.TotalLoadC = (double)functionOutputResult.FunctionOutputs.First().Value;
}
catch (ArcGIS.Core.Data.GeodatabaseUtilityNetworkException e)
{
// No C phase connectivity to source
if (!e.Message.Equals("No subnetwork source was discovered."))
{
results.Success = false;
results.Message += "No Subnetwork source was discovered for Phase C.\n";
}
}
}
// append success message to the output string
results.Message += "Trace successful.";
results.Success = true;
}
}
}
}
}
return(results);
}
public void OnPopulateTiers(Tier[] tiers)
{
Debug.Log("OnPopulateTiers");
tiersText.text = "Available Tiers: \n";
for(int i = 0; i < tiers.Length; i++) {
Tier tier = tiers[i];
tiersText.text += "Tier " + i + " : " + tier.GetName() + " (Mult.: " + tier.GetMultiplier() + " - Start/End: " + tier.GetStartValue() + "/" + tier.GetEndValue() + " - Req. Points/Secure %: " + tier.GetRequiredPoints() + "/" + tier.GetSecurePercent() + ")\n";
}
}
public IOfferOperations LoadBalance(LoadBalancerMode mode, Tier tier, string farm, Action <IOfferRemoteOperations> remote)
{
return(ExecuteRemoteWithLoadBalancer(mode, remote, _settings.Config.Servers.ToList(), farm));
}
public Item(string itemName, Tier tier)
{
this.itemName = itemName;
this.tier = tier;
}
public Task GetImageLeaderboardAsync(string imageName, DivisionWithCategory division, Tier tier, int pageNumber = 1) => GetImageLeaderboardImplementationAsync(imageName, null, division.Category, division.Division, tier, pageNumber);
public Invalid_tier_details_exception(Tier tier)
: base("Invalid tier details")
{
Tier = tier;
}
public NovaSkill(string name, int reqStr, int reqAgi, int reqInt, Tier tier, int manaCost, int speed)
: base(name, reqStr, reqAgi, reqInt, tier, manaCost)
{
this.Speed = speed;
}
public Task GetImageLeaderboardAsync(
[Summary("The image for which information should be retrieved. The name must be an exact match.")] string imageName,
[Summary("The location to which scoreboard display should be filtered, if provided."), AlterParameterDisplay(DisplayAsOptional = true)] LocationCode location,
[Summary("The division (and optionally category) to which scoreboard display should be filtered, if provided."), AlterParameterDisplay(DisplayAsOptional = true)] DivisionWithCategory division,
[Summary("The tier to which scoreboard display should be filtered, if provided."), AlterParameterDisplay(DisplayAsOptional = true)] Tier tier,
int pageNumber = 1) => GetImageLeaderboardImplementationAsync(imageName, location, division.Category, division.Division, tier, pageNumber);
// Wrapper for ThreadStart madness.
private void startJob(Tier t)
{
ThreadStart ts = new ThreadStart(t.Work);
Thread th = new Thread(ts);
th.Start();
}
public Task HistogramCommandAsync(Tier tier) => GenerateHistogramAsync(null, tier, null, null);
