protected ButtonWidget(ButtonWidget other)
: base(other)
{
ModRules = other.ModRules;
Text = other.Text;
Font = other.Font;
BaseLine = other.BaseLine;
TextColor = other.TextColor;
TextColorDisabled = other.TextColorDisabled;
Contrast = other.Contrast;
ContrastColor = other.ContrastColor;
Depressed = other.Depressed;
Background = other.Background;
VisualHeight = other.VisualHeight;
GetText = other.GetText;
GetColor = other.GetColor;
GetColorDisabled = other.GetColorDisabled;
GetContrastColor = other.GetContrastColor;
OnMouseDown = other.OnMouseDown;
Disabled = other.Disabled;
IsDisabled = other.IsDisabled;
Highlighted = other.Highlighted;
IsHighlighted = other.IsHighlighted;
OnMouseUp = mi => OnClick();
OnKeyPress = _ => OnClick();
TooltipTemplate = other.TooltipTemplate;
TooltipText = other.TooltipText;
GetTooltipText = other.GetTooltipText;
TooltipContainer = other.TooltipContainer;
tooltipContainer = Exts.Lazy(() =>
Ui.Root.Get<TooltipContainerWidget>(TooltipContainer));
}
public void Run(Action<string> emitError, Action<string> emitWarning, Ruleset rules)
{
foreach (var weaponInfo in rules.Weapons)
{
var warheads = weaponInfo.Value.Warheads.OfType<SpawnActorWarhead>().ToList();
foreach (var warhead in warheads)
{
foreach (var a in warhead.Actors)
{
if (!rules.Actors.ContainsKey(a.ToLowerInvariant()))
{
emitError("Warhead type {0} tries to spawn invalid actor {1}!"
.F(weaponInfo.Key, a));
break;
}
if (!rules.Actors[a.ToLowerInvariant()].HasTraitInfo<IPositionableInfo>())
emitError("Warhead type {0} tries to spawn unpositionable actor {1}!"
.F(weaponInfo.Key, a));
if (!rules.Actors[a.ToLowerInvariant()].HasTraitInfo<ParachutableInfo>() && warhead.Paradrop == true)
emitError("Warhead type {0} tries to paradrop actor {1} which doesn't have the Parachutable trait!"
.F(weaponInfo.Key, a));
}
}
}
}
public TileSelectorLogic(Widget widget, WorldRenderer worldRenderer, Ruleset modRules)
{
var tileset = modRules.TileSets[worldRenderer.World.Map.Tileset];
editor = widget.Parent.Get<EditorViewportControllerWidget>("MAP_EDITOR");
panel = widget.Get<ScrollPanelWidget>("TILETEMPLATE_LIST");
itemTemplate = panel.Get<ScrollItemWidget>("TILEPREVIEW_TEMPLATE");
panel.Layout = new GridLayout(panel);
var tileCategorySelector = widget.Get<DropDownButtonWidget>("TILE_CATEGORY");
var categories = tileset.EditorTemplateOrder;
Func<string, ScrollItemWidget, ScrollItemWidget> setupItem = (option, template) =>
{
var item = ScrollItemWidget.Setup(template,
() => tileCategorySelector.Text == option,
() => { tileCategorySelector.Text = option; IntializeTilePreview(widget, worldRenderer, tileset, option); });
item.Get<LabelWidget>("LABEL").GetText = () => option;
return item;
};
tileCategorySelector.OnClick = () =>
tileCategorySelector.ShowDropDown("LABEL_DROPDOWN_TEMPLATE", 270, categories, setupItem);
tileCategorySelector.Text = categories.First();
IntializeTilePreview(widget, worldRenderer, tileset, categories.First());
}
public void Run(Action<string> emitError, Action<string> emitWarning, Ruleset rules)
{
foreach (var weaponInfo in rules.Weapons)
{
var missile = weaponInfo.Value.Projectile as MissileInfo;
if (missile != null)
{
var minAngle = missile.MinimumLaunchAngle.Angle;
var maxAngle = missile.MaximumLaunchAngle.Angle;
// If both angles are identical, we only need to test one of them
var testMaxAngle = minAngle != maxAngle;
CheckLaunchAngles(weaponInfo.Key, minAngle, testMaxAngle, maxAngle, emitError);
}
var bullet = weaponInfo.Value.Projectile as BulletInfo;
if (bullet != null)
{
var minAngle = bullet.LaunchAngle[0].Angle;
var maxAngle = bullet.LaunchAngle.Length > 1 ? bullet.LaunchAngle[1].Angle : minAngle;
// If both angles are identical, we only need to test one of them
var testMaxAngle = minAngle != maxAngle;
CheckLaunchAngles(weaponInfo.Key, minAngle, testMaxAngle, maxAngle, emitError);
}
}
}
public void Run(Action<string> emitError, Action<string> emitWarning, Ruleset rules)
{
foreach (var actorInfo in rules.Actors)
{
if (actorInfo.Key.StartsWith("^"))
continue;
var count = actorInfo.Value.TraitInfos<IDefaultVisibilityInfo>().Count();
if (count == 0)
emitError("Actor type `{0}` does not define a default visibility type!".F(actorInfo.Key));
else if (count > 1)
emitError("Actor type `{0}` defines multiple default visibility types!".F(actorInfo.Key));
else
{
var vis = actorInfo.Value.TraitInfoOrDefault<HiddenUnderShroudInfo>();
if (vis != null && vis.Type == VisibilityType.Footprint)
{
var ios = actorInfo.Value.TraitInfoOrDefault<IOccupySpaceInfo>();
if (ios == null)
emitError("Actor type `{0}` defines VisibilityType.Footprint in `{1}` but has no IOccupySpace traits!".F(actorInfo.Key, vis.GetType()));
else if (!ios.OccupiedCells(actorInfo.Value, CPos.Zero).Any())
emitError("Actor type `{0}` defines VisibilityType.Footprint in `{1}` but does not have any footprint cells!".F(actorInfo.Key, vis.GetType()));
}
}
}
}
static void CheckUpgradesUsage(Action<string> emitError, Action<string> emitWarning, Ruleset rules)
{
var upgradesUsed = GetAllUsedUpgrades(emitError, rules).ToHashSet();
// Check all upgrades granted by traits.
foreach (var actorInfo in rules.Actors)
{
foreach (var trait in actorInfo.Value.TraitInfos<ITraitInfo>())
{
var fields = trait.GetType().GetFields();
foreach (var field in fields.Where(x => x.HasAttribute<UpgradeGrantedReferenceAttribute>()))
{
var values = LintExts.GetFieldValues(trait, field, emitError);
foreach (var value in values.Where(x => !upgradesUsed.Contains(x)))
emitWarning("Actor type `{0}` grants upgrade `{1}` that is not used by anything!".F(actorInfo.Key, value));
}
}
}
// Check all upgrades granted by warheads.
foreach (var weapon in rules.Weapons)
{
foreach (var warhead in weapon.Value.Warheads)
{
var fields = warhead.GetType().GetFields();
foreach (var field in fields.Where(x => x.HasAttribute<UpgradeGrantedReferenceAttribute>()))
{
var values = LintExts.GetFieldValues(warhead, field, emitError);
foreach (var value in values.Where(x => !upgradesUsed.Contains(x)))
emitWarning("Weapon type `{0}` grants upgrade `{1}` that is not used by anything!".F(weapon.Key, value));
}
}
}
}
public static void LoadMapSettings(Session.Global gs, Ruleset rules)
{
var devMode = rules.Actors["player"].TraitInfo<DeveloperModeInfo>();
gs.AllowCheats = devMode.Enabled;
var crateSpawner = rules.Actors["world"].TraitInfoOrDefault<CrateSpawnerInfo>();
gs.Crates = crateSpawner != null && crateSpawner.Enabled;
var shroud = rules.Actors["player"].TraitInfo<ShroudInfo>();
gs.Fog = shroud.FogEnabled;
gs.Shroud = !shroud.ExploredMapEnabled;
var resources = rules.Actors["player"].TraitInfo<PlayerResourcesInfo>();
gs.StartingCash = resources.DefaultCash;
var startingUnits = rules.Actors["world"].TraitInfoOrDefault<SpawnMPUnitsInfo>();
gs.StartingUnitsClass = startingUnits == null ? "none" : startingUnits.StartingUnitsClass;
var mapBuildRadius = rules.Actors["world"].TraitInfoOrDefault<MapBuildRadiusInfo>();
gs.AllyBuildRadius = mapBuildRadius != null && mapBuildRadius.AllyBuildRadiusEnabled;
var mapCreeps = rules.Actors["world"].TraitInfoOrDefault<MapCreepsInfo>();
gs.Creeps = mapCreeps != null && mapCreeps.Enabled;
var mapOptions = rules.Actors["world"].TraitInfo<MapOptionsInfo>();
gs.ShortGame = mapOptions.ShortGameEnabled;
gs.TechLevel = mapOptions.TechLevel;
gs.Difficulty = mapOptions.Difficulty ?? mapOptions.Difficulties.FirstOrDefault();
}
public void story_data_is_observed_during_invocation()
{
var data = new List<KeyValuePair<string, object>>()
{
new KeyValuePair<string, object>("bool_value", true),
new KeyValuePair<string, object>("int_value", 123),
new KeyValuePair<string, object>("string_value", "test!"),
};
var handlerRules = new Ruleset<IStory, IStoryHandler>()
{
Rules = {
new PredicateRule(
_ => true, // always run for story
_ => new ActionHandler(
(story) => Assert.AreEqual(0, story.Data.Count()), // make sure OnStart() is invoked with zero data items.
(story, task) => Assert.IsTrue(data.SequenceEqual(story.Data))) // make sure OnStop() is invoked with 3 data items.
),
},
};
new Story("testStory", handlerRules).Run(story =>
{
foreach (var kvp in data)
{
story.Data[kvp.Key] = kvp.Value;
}
});
}
public ScrollItemWidget(Ruleset modRules)
: base(modRules)
{
IsVisible = () => false;
VisualHeight = 0;
IgnoreChildMouseOver = true;
}
public void Run(Action<string> emitError, Action<string> emitWarning, Ruleset rules)
{
foreach (var actorInfo in rules.Actors)
{
var healthTraits = actorInfo.Value.TraitInfos<HealthInfo>().ToList();
if (!healthTraits.Any())
continue;
var targetable = actorInfo.Value.TraitInfos<ITargetableInfo>().SelectMany(x => x.GetTargetTypes()).ToList();
if (!targetable.Any())
continue;
foreach (var weaponInfo in rules.Weapons)
{
var warheadAS = weaponInfo.Value.Warheads.OfType<WarheadAS>();
foreach (var wh in warheadAS)
{
// This warhead cannot affect this actor.
if (!wh.ValidTargets.Overlaps(targetable))
continue;
if (healthTraits.Any(x => x.Shape.OuterRadius.Length > wh.TargetSearchRadius.Length))
emitError("Actor type `{0}` has a health radius exceeding the victim scan radius of an AS warhead on `{1}`!"
.F(actorInfo.Key, weaponInfo.Key));
}
}
}
}
public void Run(Action<string> emitError, Action<string> emitWarning, Ruleset rules)
{
foreach (var actorInfo in rules.Actors)
{
var healthTraits = actorInfo.Value.TraitInfos<HealthInfo>().ToList();
if (!healthTraits.Any())
continue;
var targetable = actorInfo.Value.TraitInfos<ITargetableInfo>().SelectMany(x => x.GetTargetTypes()).ToList();
if (!targetable.Any())
continue;
foreach (var weaponInfo in rules.Weapons)
{
var warheads = weaponInfo.Value.Warheads.OfType<SpreadDamageWarhead>().Where(dw => dw.Damage > 0);
foreach (var warhead in warheads)
{
// This is a special warhead, like the one on `weathering` in D2k.
if (!warhead.DamageTypes.Any())
continue;
// This warhead cannot affect this actor.
if (!warhead.ValidTargets.Overlaps(targetable))
continue;
if (healthTraits.Where(x => x.Radius.Length > warhead.TargetExtraSearchRadius.Length).Any())
emitError("Actor type `{0}` has a health radius exceeding the victim scan radius of a warhead on `{1}`!"
.F(actorInfo.Key, weaponInfo.Key));
}
}
}
}
static void CheckUpgradesValidity(Action<string> emitError, Ruleset rules)
{
var upgradesGranted = GetAllGrantedUpgrades(emitError, rules).ToHashSet();
foreach (var actorInfo in rules.Actors)
{
if (actorInfo.Key.StartsWith("^"))
continue;
foreach (var trait in actorInfo.Value.TraitInfos<ITraitInfo>())
{
var fields = trait.GetType().GetFields();
foreach (var field in fields.Where(x => x.HasAttribute<UpgradeUsedReferenceAttribute>()))
{
var values = LintExts.GetFieldValues(trait, field, emitError);
foreach (var value in values)
{
if (!upgradesGranted.Contains(value))
emitError("Actor type `{0}` uses upgrade `{1}` that is not granted by anything!".F(actorInfo.Key, value));
if (actorInfo.Value.TraitInfoOrDefault<UpgradeManagerInfo>() == null)
emitError("Actor type `{0}` uses upgrade `{1}`, but doesn't have the UpgradeManager trait.".F(actorInfo.Key, value));
}
}
}
}
}
public static void ShowSlotDropDown(Ruleset rules, DropDownButtonWidget dropdown, Session.Slot slot,
Session.Client client, OrderManager orderManager)
{
var options = new Dictionary<string, IEnumerable<SlotDropDownOption>>() {{"Slot", new List<SlotDropDownOption>()
{
new SlotDropDownOption("Open", "slot_open "+slot.PlayerReference, () => (!slot.Closed && client == null)),
new SlotDropDownOption("Closed", "slot_close "+slot.PlayerReference, () => slot.Closed)
}}};
var bots = new List<SlotDropDownOption>();
if (slot.AllowBots)
{
foreach (var b in rules.Actors["player"].Traits.WithInterface<IBotInfo>().Select(t => t.Name))
{
var bot = b;
var botController = orderManager.LobbyInfo.Clients.FirstOrDefault(c => c.IsAdmin);
bots.Add(new SlotDropDownOption(bot,
"slot_bot {0} {1} {2}".F(slot.PlayerReference, botController.Index, bot),
() => client != null && client.Bot == bot));
}
}
options.Add(bots.Any() ? "Bots" : "Bots Disabled", bots);
Func<SlotDropDownOption, ScrollItemWidget, ScrollItemWidget> setupItem = (o, itemTemplate) =>
{
var item = ScrollItemWidget.Setup(itemTemplate,
o.Selected,
() => orderManager.IssueOrder(Order.Command(o.Order)));
item.Get<LabelWidget>("LABEL").GetText = () => o.Title;
return item;
};
dropdown.ShowDropDown<SlotDropDownOption>("LABEL_DROPDOWN_TEMPLATE", 167, options, setupItem);
}
public CncInstallMusicLogic(Widget widget, Ruleset modRules, Action onExit)
{
var installButton = widget.GetOrNull<ButtonWidget>("INSTALL_BUTTON");
if (installButton != null)
{
Action afterInstall = () =>
{
try
{
var path = new string[] { Platform.SupportDir, "Content", Game.modData.Manifest.Mod.Id }.Aggregate(Path.Combine);
GlobalFileSystem.Mount(Path.Combine(path, "scores.mix"));
GlobalFileSystem.Mount(Path.Combine(path, "transit.mix"));
modRules.Music.Do(m => m.Value.Reload());
var musicPlayerLogic = (MusicPlayerLogic)installButton.Parent.LogicObject;
musicPlayerLogic.BuildMusicTable();
}
catch (Exception e)
{
Log.Write("debug", "Mounting the new mixfile and rebuild of scores list failed:\n{0}", e);
}
};
installButton.OnClick = () =>
Ui.OpenWindow("INSTALL_MUSIC_PANEL", new WidgetArgs() {
{ "afterInstall", afterInstall },
{ "filesToCopy", new[] { "SCORES.MIX" } },
{ "filesToExtract", new[] { "transit.mix" } },
});
installButton.IsVisible = () => modRules.InstalledMusic.ToArray().Length < 3; // HACK around music being split between transit.mix and scores.mix
}
}
public void Run(Action<string> emitError, Action<string> emitWarning, Ruleset rules)
{
foreach (var actorData in D2kMapImporter.ActorDataByActorCode.Values)
{
if (!rules.Actors.ContainsKey(actorData.First))
emitError("Undefined actor {0} in map import code.".F(actorData.First));
}
}
public void story_exception_thrown_is_propagated()
{
var handlerRules = new Ruleset<IStory, IStoryHandler>();
new Story("testStory", handlerRules).Run(story =>
{
throw new InvalidOperationException("oh oh");
});
}
public void story_exception_thrown_is_propagated()
{
var handlerRules = new Ruleset<IStory, IStoryHandler>();
Storytelling.StartNew("testStory", () =>
{
throw new InvalidOperationException("oh oh");
});
}
// Add the static resources defined in the map; if the map lives
// in a world use AddCustomTerrain instead
static Bitmap AddStaticResources(TileSet tileset, Map map, Ruleset resourceRules, Bitmap terrainBitmap)
{
var terrain = new Bitmap(terrainBitmap);
var isRectangularIsometric = map.Grid.Type == MapGridType.RectangularIsometric;
var b = map.Bounds;
// Fudge the heightmap offset by adding as much extra as we need / can
// This tries to correct for our incorrect assumption that MPos == PPos
var heightOffset = Math.Min(map.Grid.MaximumTerrainHeight, map.MapSize.Y - b.Bottom);
var width = b.Width;
var height = b.Height + heightOffset;
var resources = resourceRules.Actors["world"].TraitInfos<ResourceTypeInfo>()
.ToDictionary(r => r.ResourceType, r => r.TerrainType);
var bitmapData = terrain.LockBits(terrain.Bounds(),
ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
unsafe
{
var colors = (int*)bitmapData.Scan0;
var stride = bitmapData.Stride / 4;
for (var y = 0; y < height; y++)
{
for (var x = 0; x < width; x++)
{
var uv = new MPos(x + b.Left, y + b.Top);
if (map.MapResources.Value[uv].Type == 0)
continue;
string res;
if (!resources.TryGetValue(map.MapResources.Value[uv].Type, out res))
continue;
var color = tileset[tileset.GetTerrainIndex(res)].Color.ToArgb();
if (isRectangularIsometric)
{
// Odd rows are shifted right by 1px
var dx = uv.V & 1;
if (x + dx > 0)
colors[y * stride + 2 * x + dx - 1] = color;
if (2 * x + dx < stride)
colors[y * stride + 2 * x + dx] = color;
}
else
colors[y * stride + x] = color;
}
}
}
terrain.UnlockBits(bitmapData);
return terrain;
}
public MusicPlayerLogic(Widget widget, Ruleset modRules, Action onExit)
{
this.modRules = modRules;
var panel = widget.Get("MUSIC_PANEL");
musicList = panel.Get<ScrollPanelWidget>("MUSIC_LIST");
itemTemplate = musicList.Get<ScrollItemWidget>("MUSIC_TEMPLATE");
BuildMusicTable();
Func<bool> noMusic = () => !installed;
panel.Get("NO_MUSIC_LABEL").IsVisible = noMusic;
var playButton = panel.Get<ButtonWidget>("BUTTON_PLAY");
playButton.OnClick = Play;
playButton.IsDisabled = noMusic;
playButton.IsVisible = () => !Sound.MusicPlaying;
var pauseButton = panel.Get<ButtonWidget>("BUTTON_PAUSE");
pauseButton.OnClick = Sound.PauseMusic;
pauseButton.IsDisabled = noMusic;
pauseButton.IsVisible = () => Sound.MusicPlaying;
var stopButton = panel.Get<ButtonWidget>("BUTTON_STOP");
stopButton.OnClick = Sound.StopMusic;
stopButton.IsDisabled = noMusic;
var nextButton = panel.Get<ButtonWidget>("BUTTON_NEXT");
nextButton.OnClick = () => { currentSong = GetNextSong(); Play(); };
nextButton.IsDisabled = noMusic;
var prevButton = panel.Get<ButtonWidget>("BUTTON_PREV");
prevButton.OnClick = () => { currentSong = GetPrevSong(); Play(); };
prevButton.IsDisabled = noMusic;
var shuffleCheckbox = panel.Get<CheckboxWidget>("SHUFFLE");
shuffleCheckbox.IsChecked = () => Game.Settings.Sound.Shuffle;
shuffleCheckbox.OnClick = () => Game.Settings.Sound.Shuffle ^= true;
var repeatCheckbox = panel.Get<CheckboxWidget>("REPEAT");
repeatCheckbox.IsChecked = () => Game.Settings.Sound.Repeat;
repeatCheckbox.OnClick = () => Game.Settings.Sound.Repeat ^= true;
panel.Get<LabelWidget>("TIME_LABEL").GetText = () => (currentSong == null) ? "" :
"{0:D2}:{1:D2} / {2:D2}:{3:D2}".F((int)Sound.MusicSeekPosition / 60, (int)Sound.MusicSeekPosition % 60,
currentSong.Length / 60, currentSong.Length % 60);
var musicSlider = panel.Get<SliderWidget>("MUSIC_SLIDER");
musicSlider.OnChange += x => Sound.MusicVolume = x;
musicSlider.Value = Sound.MusicVolume;
panel.Get<ButtonWidget>("BACK_BUTTON").OnClick = () => { Game.Settings.Save(); Ui.CloseWindow(); onExit(); };
}
public void Run(Action<string> emitError, Action<string> emitWarning, Ruleset rules)
{
foreach (var weaponInfo in rules.Weapons)
{
var range = weaponInfo.Value.Range;
var missile = weaponInfo.Value.Projectile as MissileInfo;
if (missile != null && missile.RangeLimit > WDist.Zero && missile.RangeLimit < range)
emitError("Weapon `{0}`: projectile RangeLimit lower than weapon range!"
.F(weaponInfo.Key));
}
}
public void story_detaches_correctly()
{
var handlerRules = new Ruleset<IStory, IStoryHandler>();
var story1 = new Story("story1", handlerRules);
Assert.AreEqual("story1", story1.Name);
story1.Detach();
var story2 = new Story("story2", handlerRules);
Assert.AreEqual("story2", story2.Name);
story2.Detach();
}
public LayerSelectorLogic(Widget widget, WorldRenderer worldRenderer, Ruleset modRules)
{
this.modRules = modRules;
this.worldRenderer = worldRenderer;
this.world = worldRenderer.World;
editor = widget.Parent.Get<EditorViewportControllerWidget>("MAP_EDITOR");
layerTemplateList = widget.Get<ScrollPanelWidget>("LAYERTEMPLATE_LIST");
layerTemplateList.Layout = new GridLayout(layerTemplateList);
layerPreviewTemplate = layerTemplateList.Get<ScrollItemWidget>("LAYERPREVIEW_TEMPLATE");
IntializeLayerPreview(widget);
}
public void Run(Action<string> emitError, Action<string> emitWarning, Ruleset rules)
{
foreach (var actorInfo in rules.Actors)
{
var building = actorInfo.Value.TraitInfoOrDefault<BuildingInfo>();
if (building == null)
continue;
var footprint = building.Footprint.Where(x => !char.IsWhiteSpace(x)).ToArray();
var dimension = building.Dimensions;
if (footprint.Length != dimension.X * dimension.Y)
emitError("Invalid building footprint/dimension for " + actorInfo.Key);
}
}
public void Run(Action<string> emitError, Action<string> emitWarning, Ruleset rules)
{
foreach (var actorInfo in rules.Actors)
{
if (actorInfo.Key.StartsWith("^", StringComparison.Ordinal))
continue;
var granted = new HashSet<string>();
var consumed = new HashSet<string>();
foreach (var trait in actorInfo.Value.TraitInfos<ITraitInfo>())
{
var fieldConsumed = trait.GetType().GetFields()
.Where(x => x.HasAttribute<ConsumedConditionReferenceAttribute>())
.SelectMany(f => LintExts.GetFieldValues(trait, f, emitError));
var propertyConsumed = trait.GetType().GetProperties()
.Where(x => x.HasAttribute<ConsumedConditionReferenceAttribute>())
.SelectMany(p => LintExts.GetPropertyValues(trait, p, emitError));
var fieldGranted = trait.GetType().GetFields()
.Where(x => x.HasAttribute<GrantedConditionReferenceAttribute>())
.SelectMany(f => LintExts.GetFieldValues(trait, f, emitError));
var propertyGranted = trait.GetType().GetProperties()
.Where(x => x.HasAttribute<GrantedConditionReferenceAttribute>())
.SelectMany(f => LintExts.GetPropertyValues(trait, f, emitError));
foreach (var c in fieldConsumed.Concat(propertyConsumed))
if (!string.IsNullOrEmpty(c))
consumed.Add(c);
foreach (var g in fieldGranted.Concat(propertyGranted))
if (!string.IsNullOrEmpty(g))
granted.Add(g);
}
var unconsumed = granted.Except(consumed);
if (unconsumed.Any())
emitWarning("Actor type `{0}` grants conditions that are not consumed: {1}".F(actorInfo.Key, unconsumed.JoinWith(", ")));
var ungranted = consumed.Except(granted);
if (ungranted.Any())
emitError("Actor type `{0}` consumes conditions that are not granted: {1}".F(actorInfo.Key, ungranted.JoinWith(", ")));
if ((consumed.Any() || granted.Any()) && actorInfo.Value.TraitInfoOrDefault<UpgradeManagerInfo>() == null)
emitError("Actor type `{0}` defines conditions but does not include an UpgradeManager".F(actorInfo.Key));
}
}
public static IEnumerable<CPos> Tiles(Ruleset rules, string name, BuildingInfo buildingInfo, CPos topLeft)
{
var dim = (CVec)buildingInfo.Dimensions;
var footprint = buildingInfo.Footprint.Where(x => !char.IsWhiteSpace(x));
var buildingTraits = rules.Actors[name].Traits;
if (buildingTraits.Contains<BibInfo>() && !(buildingTraits.Get<BibInfo>().HasMinibib))
{
dim += new CVec(0, 1);
footprint = footprint.Concat(new char[dim.X]);
}
return TilesWhere( name, dim, footprint.ToArray(), a => a != '_' ).Select( t => t + topLeft );
}
public static IEnumerable<CPos> Tiles(Ruleset rules, string name, BuildingInfo buildingInfo, CPos topLeft, bool includePassable = false)
{
var dim = buildingInfo.Dimensions;
var footprint = buildingInfo.Footprint.Where(x => !char.IsWhiteSpace(x));
var bibInfo = rules.Actors[name].TraitInfoOrDefault<BibInfo>();
if (bibInfo != null && !bibInfo.HasMinibib)
{
dim += new CVec(0, 1);
footprint = footprint.Concat(new char[dim.X]);
}
return TilesWhere(name, dim, footprint.ToArray(), a => includePassable || a != '_').Select(t => t + topLeft);
}
public ButtonWidget(Ruleset modRules)
{
this.modRules = modRules;
GetText = () => { return Text; };
GetColor = () => TextColor;
GetColorDisabled = () => TextColorDisabled;
GetContrastColor = () => ContrastColor;
OnMouseUp = _ => OnClick();
OnKeyPress = _ => OnClick();
IsDisabled = () => Disabled;
IsHighlighted = () => Highlighted;
tooltipContainer = Exts.Lazy(() =>
Ui.Root.Get<TooltipContainerWidget>(TooltipContainer));
}
public void Run(Action<string> emitError, Action<string> emitWarning, Ruleset rules)
{
foreach (var actorInfo in rules.Actors)
{
var healthTraits = actorInfo.Value.TraitInfos<HealthInfo>().ToList();
if (!healthTraits.Any())
continue;
var targetable = actorInfo.Value.TraitInfos<ITargetableInfo>().SelectMany(x => x.GetTargetTypes()).ToList();
if (!targetable.Any())
continue;
foreach (var weaponInfo in rules.Weapons)
{
var warheads = weaponInfo.Value.Warheads.OfType<SpreadDamageWarhead>().Where(dw => dw.Damage > 0);
foreach (var warhead in warheads)
{
// This is a special warhead, like the one on `weathering` in D2k.
if (!warhead.DamageTypes.Any())
continue;
// This warhead cannot affect this actor.
if (!warhead.ValidTargets.Overlaps(targetable))
continue;
if (healthTraits.Where(x => x.Shape.OuterRadius.Length > warhead.TargetExtraSearchRadius.Length).Any())
emitError("Actor type `{0}` has a health radius exceeding the victim scan radius of a warhead on `{1}`!"
.F(actorInfo.Key, weaponInfo.Key));
}
var bullet = weaponInfo.Value.Projectile as BulletInfo;
var missile = weaponInfo.Value.Projectile as MissileInfo;
var areabeam = weaponInfo.Value.Projectile as AreaBeamInfo;
if (bullet == null && missile == null && areabeam == null)
continue;
var targetExtraSearchRadius = bullet != null ? bullet.TargetExtraSearchRadius :
missile != null ? missile.TargetExtraSearchRadius :
areabeam != null ? areabeam.TargetExtraSearchRadius : WDist.Zero;
if (healthTraits.Where(x => x.Shape.OuterRadius.Length > targetExtraSearchRadius.Length).Any())
emitError("Actor type `{0}` has a health radius exceeding the victim scan radius of the projectile on `{1}`!"
.F(actorInfo.Key, weaponInfo.Key));
}
}
}
public void Run(Action<string> emitError, Action<string> emitWarning, Ruleset rules)
{
foreach (var actorInfo in rules.Actors.Where(a => !a.Key.StartsWith("^")))
{
try
{
var hasTraits = actorInfo.Value.TraitsInConstructOrder().Any();
if (!hasTraits)
emitWarning("Actor {0} has no traits. Is this intended?".F(actorInfo.Key));
}
catch (Exception e)
{
emitError("Actor {0} is not constructible; failure: {1}".F(actorInfo.Key, e.Message));
}
}
}
public ButtonWidget(ModData modData)
{
ModRules = modData.DefaultRules;
GetText = () => Text;
GetColor = () => TextColor;
GetColorDisabled = () => TextColorDisabled;
GetContrastColor = () => ContrastColor;
OnMouseUp = _ => OnClick();
OnKeyPress = _ => OnClick();
IsDisabled = () => Disabled;
IsHighlighted = () => Highlighted;
GetTooltipText = () => TooltipText;
tooltipContainer = Exts.Lazy(() =>
Ui.Root.Get<TooltipContainerWidget>(TooltipContainer));
}
public IngameChatLogic(Widget widget, OrderManager orderManager, World world, ModData modData, bool isMenuChat, Dictionary <string, MiniYaml> logicArgs)
{
this.orderManager = orderManager;
modRules = modData.DefaultRules;
chatTraits = world.WorldActor.TraitsImplementing <INotifyChat>().ToArray();
var players = world.Players.Where(p => p != world.LocalPlayer && !p.NonCombatant && !p.IsBot);
var isObserver = orderManager.LocalClient != null && orderManager.LocalClient.IsObserver;
var alwaysDisabled = world.IsReplay || world.LobbyInfo.NonBotClients.Count() == 1;
var disableTeamChat = alwaysDisabled || (world.LocalPlayer != null && !players.Any(p => p.IsAlliedWith(world.LocalPlayer)));
var teamChat = !disableTeamChat;
tabCompletion.Commands = chatTraits.OfType <ChatCommands>().SelectMany(x => x.Commands.Keys).ToList();
tabCompletion.Names = orderManager.LobbyInfo.Clients.Select(c => c.Name).Distinct().ToList();
var chatPanel = (ContainerWidget)widget;
chatOverlay = chatPanel.GetOrNull <ContainerWidget>("CHAT_OVERLAY");
if (chatOverlay != null)
{
chatOverlayDisplay = chatOverlay.Get <ChatDisplayWidget>("CHAT_DISPLAY");
chatOverlay.Visible = false;
}
chatChrome = chatPanel.Get <ContainerWidget>("CHAT_CHROME");
chatChrome.Visible = true;
var chatMode = chatChrome.Get <ButtonWidget>("CHAT_MODE");
chatMode.GetText = () => teamChat && !disableTeamChat ? "Team" : "All";
chatMode.OnClick = () => teamChat ^= true;
// Enable teamchat if we are a player and die,
// or disable it when we are the only one left in the team
if (!alwaysDisabled && world.LocalPlayer != null)
{
chatMode.IsDisabled = () =>
{
if (world.IsGameOver)
{
return(true);
}
// The game is over for us, join spectator team chat
if (world.LocalPlayer.WinState != WinState.Undefined)
{
disableTeamChat = false;
return(disableTeamChat);
}
// If team chat isn't already disabled, check if we are the only living team member
if (!disableTeamChat)
{
disableTeamChat = players.All(p => p.WinState != WinState.Undefined || !p.IsAlliedWith(world.LocalPlayer));
}
return(disableTeamChat);
};
}
else
{
chatMode.IsDisabled = () => disableTeamChat;
}
// Disable team chat after the game ended
world.GameOver += () => disableTeamChat = true;
chatText = chatChrome.Get <TextFieldWidget>("CHAT_TEXTFIELD");
chatText.MaxLength = UnitOrders.ChatMessageMaxLength;
chatText.OnEnterKey = () =>
{
var team = teamChat && !disableTeamChat;
if (chatText.Text != "")
{
if (!chatText.Text.StartsWith("/", StringComparison.Ordinal))
{
// This should never happen, but avoid a crash if it does somehow (chat will just stay open)
if (!isObserver && orderManager.LocalClient == null && world.LocalPlayer == null)
{
return(true);
}
var teamNumber = 0U;
if (team)
{
teamNumber = (isObserver || world.LocalPlayer.WinState != WinState.Undefined) ? uint.MaxValue : (uint)orderManager.LocalClient.Team;
}
orderManager.IssueOrder(Order.Chat(chatText.Text.Trim(), teamNumber));
}
else if (chatTraits != null)
{
var text = chatText.Text.Trim();
var from = world.IsReplay ? null : orderManager.LocalClient.Name;
foreach (var trait in chatTraits)
{
trait.OnChat(from, text);
}
}
}
chatText.Text = "";
if (!isMenuChat)
{
CloseChat();
}
return(true);
};
chatText.OnTabKey = () =>
{
var previousText = chatText.Text;
chatText.Text = tabCompletion.Complete(chatText.Text);
chatText.CursorPosition = chatText.Text.Length;
if (chatText.Text == previousText && !disableTeamChat)
{
teamChat ^= true;
}
return(true);
};
chatText.OnEscKey = () =>
{
if (!isMenuChat)
{
CloseChat();
}
else
{
chatText.YieldKeyboardFocus();
}
return(true);
};
if (!isMenuChat)
{
var chatClose = chatChrome.Get <ButtonWidget>("CHAT_CLOSE");
chatClose.OnClick += CloseChat;
chatPanel.OnKeyPress = e =>
{
if (e.Event == KeyInputEvent.Up)
{
return(false);
}
if (!chatChrome.IsVisible() && (e.Key == Keycode.RETURN || e.Key == Keycode.KP_ENTER))
{
OpenChat();
return(true);
}
return(false);
};
}
chatScrollPanel = chatChrome.Get <ScrollPanelWidget>("CHAT_SCROLLPANEL");
chatTemplate = chatScrollPanel.Get <ContainerWidget>("CHAT_TEMPLATE");
chatScrollPanel.RemoveChildren();
chatScrollPanel.ScrollToBottom();
foreach (var chatLine in orderManager.ChatCache)
{
AddChatLine(chatLine.Name, chatLine.Color, chatLine.Text, chatLine.TextColor, true);
}
orderManager.AddChatLine += AddChatLineWrapper;
chatText.IsDisabled = () => world.IsReplay && !Game.Settings.Debug.EnableDebugCommandsInReplays;
if (!isMenuChat)
{
CloseChat();
var keyListener = chatChrome.Get <LogicKeyListenerWidget>("KEY_LISTENER");
keyListener.AddHandler(e =>
{
if (e.Event == KeyInputEvent.Up || !chatText.IsDisabled())
{
return(false);
}
if ((e.Key == Keycode.RETURN || e.Key == Keycode.KP_ENTER || e.Key == Keycode.ESCAPE) && e.Modifiers == Modifiers.None)
{
CloseChat();
return(true);
}
return(false);
});
}
if (logicArgs.TryGetValue("ChatLineSound", out var yaml))
{
chatLineSound = yaml.Value;
}
}
public ActorSelectorLogic(Widget widget, World world, WorldRenderer worldRenderer, Ruleset modRules)
{
this.modRules = modRules;
this.world = world;
this.worldRenderer = worldRenderer;
editor = widget.Parent.Get <EditorViewportControllerWidget>("MAP_EDITOR");
ownersDropDown = widget.Get <DropDownButtonWidget>("OWNERS_DROPDOWN");
panel = widget.Get <ScrollPanelWidget>("ACTORTEMPLATE_LIST");
itemTemplate = panel.Get <ScrollItemWidget>("ACTORPREVIEW_TEMPLATE");
panel.Layout = new GridLayout(panel);
var editorLayer = world.WorldActor.Trait <EditorActorLayer>();
selectedOwner = editorLayer.Players.Players.Values.First();
Func <PlayerReference, ScrollItemWidget, ScrollItemWidget> setupItem = (option, template) =>
{
var item = ScrollItemWidget.Setup(template, () => selectedOwner == option, () =>
{
selectedOwner = option;
ownersDropDown.Text = selectedOwner.Name;
ownersDropDown.TextColor = selectedOwner.Color.RGB;
IntializeActorPreviews();
});
item.Get <LabelWidget>("LABEL").GetText = () => option.Name;
item.GetColor = () => option.Color.RGB;
return(item);
};
ownersDropDown.OnClick = () =>
{
var owners = editorLayer.Players.Players.Values.OrderBy(p => p.Name);
ownersDropDown.ShowDropDown("LABEL_DROPDOWN_TEMPLATE", 270, owners, setupItem);
};
ownersDropDown.Text = selectedOwner.Name;
ownersDropDown.TextColor = selectedOwner.Color.RGB;
IntializeActorPreviews();
}
protected virtual IBeatmap CreateBeatmap(Ruleset ruleset) => new TestBeatmap(ruleset.RulesetInfo);
public CrossDifficultyCalculator(Ruleset ruleset, WorkingBeatmap beatmap)
: base(ruleset, beatmap)
{
isForCurrentRuleset = beatmap.BeatmapInfo.Ruleset.Equals(ruleset.RulesetInfo);
}
public DrawableManiaRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList <Mod> mods = null)
: base(ruleset, beatmap, mods)
{
BarLines = new BarLineGenerator <BarLine>(Beatmap).BarLines;
}
protected TestCasePlayer(Ruleset ruleset)
{
this.ruleset = ruleset;
}
public TaikoDifficultyCalculator(Ruleset ruleset, WorkingBeatmap beatmap)
: base(ruleset, beatmap)
{
}
public CatchPerformanceCalculator(Ruleset ruleset, WorkingBeatmap beatmap, ScoreInfo score)
: base(ruleset, beatmap, score)
{
}
protected override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap, Ruleset ruleset)
{
var converter = base.CreateBeatmapConverter(beatmap, ruleset);
converter.ObjectConverted += (orig, converted) => ConversionGenerated?.Invoke(orig, converted, converter);
return(converter);
}
internal LobbyLogic(Widget widget, ModData modData, WorldRenderer worldRenderer, OrderManager orderManager,
Action onExit, Action onStart, bool skirmishMode)
{
map = MapCache.UnknownMap;
lobby = widget;
this.modData = modData;
this.orderManager = orderManager;
this.onStart = onStart;
this.onExit = onExit;
this.skirmishMode = skirmishMode;
// TODO: This needs to be reworked to support per-map tech levels, bots, etc.
this.modRules = modData.DefaultRules;
shellmapWorld = worldRenderer.World;
services = modData.Manifest.Get <WebServices>();
orderManager.AddChatLine += AddChatLine;
Game.LobbyInfoChanged += UpdateCurrentMap;
Game.LobbyInfoChanged += UpdatePlayerList;
Game.BeforeGameStart += OnGameStart;
Game.ConnectionStateChanged += ConnectionStateChanged;
var name = lobby.GetOrNull <LabelWidget>("SERVER_NAME");
if (name != null)
{
name.GetText = () => orderManager.LobbyInfo.GlobalSettings.ServerName;
}
Ui.LoadWidget("MAP_PREVIEW", lobby.Get("MAP_PREVIEW_ROOT"), new WidgetArgs
{
{ "orderManager", orderManager },
{ "getMap", (Func <MapPreview>)(() => map) },
{ "onMouseDown", (Action <MapPreviewWidget, MapPreview, MouseInput>)((preview, mapPreview, mi) =>
LobbyUtils.SelectSpawnPoint(orderManager, preview, mapPreview, mi)) },
{ "getSpawnOccupants", (Func <MapPreview, Dictionary <CPos, SpawnOccupant> >)(mapPreview => LobbyUtils.GetSpawnOccupants(orderManager.LobbyInfo, mapPreview)) },
{ "showUnoccupiedSpawnpoints", true },
});
UpdateCurrentMap();
var playerBin = Ui.LoadWidget("LOBBY_PLAYER_BIN", lobby.Get("TOP_PANELS_ROOT"), new WidgetArgs());
playerBin.IsVisible = () => panel == PanelType.Players;
players = playerBin.Get <ScrollPanelWidget>("LOBBY_PLAYERS");
editablePlayerTemplate = players.Get("TEMPLATE_EDITABLE_PLAYER");
nonEditablePlayerTemplate = players.Get("TEMPLATE_NONEDITABLE_PLAYER");
emptySlotTemplate = players.Get("TEMPLATE_EMPTY");
editableSpectatorTemplate = players.Get("TEMPLATE_EDITABLE_SPECTATOR");
nonEditableSpectatorTemplate = players.Get("TEMPLATE_NONEDITABLE_SPECTATOR");
newSpectatorTemplate = players.Get("TEMPLATE_NEW_SPECTATOR");
colorPreview = lobby.Get <ColorPreviewManagerWidget>("COLOR_MANAGER");
colorPreview.Color = Game.Settings.Player.Color;
foreach (var f in modRules.Actors["world"].TraitInfos <FactionInfo>())
{
factions.Add(f.InternalName, new LobbyFaction {
Selectable = f.Selectable, Name = f.Name, Side = f.Side, Description = f.Description
});
}
var gameStarting = false;
Func <bool> configurationDisabled = () => !Game.IsHost || gameStarting ||
panel == PanelType.Kick || panel == PanelType.ForceStart ||
!map.RulesLoaded || map.InvalidCustomRules ||
orderManager.LocalClient == null || orderManager.LocalClient.IsReady;
var mapButton = lobby.GetOrNull <ButtonWidget>("CHANGEMAP_BUTTON");
if (mapButton != null)
{
mapButton.IsDisabled = () => gameStarting || panel == PanelType.Kick || panel == PanelType.ForceStart ||
orderManager.LocalClient == null || orderManager.LocalClient.IsReady;
mapButton.OnClick = () =>
{
var onSelect = new Action <string>(uid =>
{
// Don't select the same map again
if (uid == map.Uid)
{
return;
}
orderManager.IssueOrder(Order.Command("map " + uid));
Game.Settings.Server.Map = uid;
Game.Settings.Save();
});
Ui.OpenWindow("MAPCHOOSER_PANEL", new WidgetArgs()
{
{ "initialMap", map.Uid },
{ "initialTab", MapClassification.System },
{ "onExit", DoNothing },
{ "onSelect", Game.IsHost ? onSelect : null },
{ "filter", MapVisibility.Lobby },
});
};
}
var slotsButton = lobby.GetOrNull <DropDownButtonWidget>("SLOTS_DROPDOWNBUTTON");
if (slotsButton != null)
{
slotsButton.IsDisabled = () => configurationDisabled() || panel != PanelType.Players ||
(orderManager.LobbyInfo.Slots.Values.All(s => !s.AllowBots) &&
orderManager.LobbyInfo.Slots.Count(s => !s.Value.LockTeam && orderManager.LobbyInfo.ClientInSlot(s.Key) != null) == 0);
slotsButton.OnMouseDown = _ =>
{
var botTypes = map.Rules.Actors["player"].TraitInfos <IBotInfo>().Select(t => t.Type);
var options = new Dictionary <string, IEnumerable <DropDownOption> >();
var botController = orderManager.LobbyInfo.Clients.FirstOrDefault(c => c.IsAdmin);
if (orderManager.LobbyInfo.Slots.Values.Any(s => s.AllowBots))
{
var botOptions = new List <DropDownOption>()
{
new DropDownOption()
{
Title = "Add",
IsSelected = () => false,
OnClick = () =>
{
foreach (var slot in orderManager.LobbyInfo.Slots)
{
var bot = botTypes.Random(Game.CosmeticRandom);
var c = orderManager.LobbyInfo.ClientInSlot(slot.Key);
if (slot.Value.AllowBots == true && (c == null || c.Bot != null))
{
orderManager.IssueOrder(Order.Command("slot_bot {0} {1} {2}".F(slot.Key, botController.Index, bot)));
}
}
}
}
};
if (orderManager.LobbyInfo.Clients.Any(c => c.Bot != null))
{
botOptions.Add(new DropDownOption()
{
Title = "Remove",
IsSelected = () => false,
OnClick = () =>
{
foreach (var slot in orderManager.LobbyInfo.Slots)
{
var c = orderManager.LobbyInfo.ClientInSlot(slot.Key);
if (c != null && c.Bot != null)
{
orderManager.IssueOrder(Order.Command("slot_open " + slot.Value.PlayerReference));
}
}
}
});
}
options.Add("Configure Bots", botOptions);
}
var teamCount = (orderManager.LobbyInfo.Slots.Count(s => !s.Value.LockTeam && orderManager.LobbyInfo.ClientInSlot(s.Key) != null) + 1) / 2;
if (teamCount >= 1)
{
var teamOptions = Enumerable.Range(2, teamCount - 1).Reverse().Select(d => new DropDownOption
{
Title = "{0} Teams".F(d),
IsSelected = () => false,
OnClick = () => orderManager.IssueOrder(Order.Command("assignteams {0}".F(d.ToString())))
}).ToList();
if (orderManager.LobbyInfo.Slots.Any(s => s.Value.AllowBots))
{
teamOptions.Add(new DropDownOption
{
Title = "Humans vs Bots",
IsSelected = () => false,
OnClick = () => orderManager.IssueOrder(Order.Command("assignteams 1"))
});
}
teamOptions.Add(new DropDownOption
{
Title = "Free for all",
IsSelected = () => false,
OnClick = () => orderManager.IssueOrder(Order.Command("assignteams 0"))
});
options.Add("Configure Teams", teamOptions);
}
Func <DropDownOption, ScrollItemWidget, ScrollItemWidget> setupItem = (option, template) =>
{
var item = ScrollItemWidget.Setup(template, option.IsSelected, option.OnClick);
item.Get <LabelWidget>("LABEL").GetText = () => option.Title;
return(item);
};
slotsButton.ShowDropDown("LABEL_DROPDOWN_TEMPLATE", 175, options, setupItem);
};
}
var optionsBin = Ui.LoadWidget("LOBBY_OPTIONS_BIN", lobby.Get("TOP_PANELS_ROOT"), new WidgetArgs());
optionsBin.IsVisible = () => panel == PanelType.Options;
var musicBin = Ui.LoadWidget("LOBBY_MUSIC_BIN", lobby.Get("TOP_PANELS_ROOT"), new WidgetArgs
{
{ "onExit", DoNothing },
{ "world", worldRenderer.World }
});
musicBin.IsVisible = () => panel == PanelType.Music;
var optionsTab = lobby.Get <ButtonWidget>("OPTIONS_TAB");
optionsTab.IsHighlighted = () => panel == PanelType.Options;
optionsTab.IsDisabled = () => !map.RulesLoaded || map.InvalidCustomRules || panel == PanelType.Kick || panel == PanelType.ForceStart;
optionsTab.OnClick = () => panel = PanelType.Options;
var playersTab = lobby.Get <ButtonWidget>("PLAYERS_TAB");
playersTab.IsHighlighted = () => panel == PanelType.Players;
playersTab.IsDisabled = () => panel == PanelType.Kick || panel == PanelType.ForceStart;
playersTab.OnClick = () => panel = PanelType.Players;
var musicTab = lobby.Get <ButtonWidget>("MUSIC_TAB");
musicTab.IsHighlighted = () => panel == PanelType.Music;
musicTab.IsDisabled = () => panel == PanelType.Kick || panel == PanelType.ForceStart;
musicTab.OnClick = () => panel = PanelType.Music;
// Force start panel
Action startGame = () =>
{
gameStarting = true;
orderManager.IssueOrder(Order.Command("startgame"));
};
var startGameButton = lobby.GetOrNull <ButtonWidget>("START_GAME_BUTTON");
if (startGameButton != null)
{
startGameButton.IsDisabled = () => configurationDisabled() || map.Status != MapStatus.Available ||
orderManager.LobbyInfo.Slots.Any(sl => sl.Value.Required && orderManager.LobbyInfo.ClientInSlot(sl.Key) == null) ||
(!orderManager.LobbyInfo.GlobalSettings.EnableSingleplayer && orderManager.LobbyInfo.NonBotPlayers.Count() < 2);
startGameButton.OnClick = () =>
{
// Bots and admins don't count
if (orderManager.LobbyInfo.Clients.Any(c => c.Slot != null && !c.IsAdmin && c.Bot == null && !c.IsReady))
{
panel = PanelType.ForceStart;
}
else
{
startGame();
}
};
}
var forceStartBin = Ui.LoadWidget("FORCE_START_DIALOG", lobby.Get("TOP_PANELS_ROOT"), new WidgetArgs());
forceStartBin.IsVisible = () => panel == PanelType.ForceStart;
forceStartBin.Get("KICK_WARNING").IsVisible = () => orderManager.LobbyInfo.Clients.Any(c => c.IsInvalid);
forceStartBin.Get <ButtonWidget>("OK_BUTTON").OnClick = startGame;
forceStartBin.Get <ButtonWidget>("CANCEL_BUTTON").OnClick = () => panel = PanelType.Players;
// Options panel
var optionCheckboxes = new Dictionary <string, string>()
{
{ "EXPLORED_MAP_CHECKBOX", "explored" },
{ "CRATES_CHECKBOX", "crates" },
{ "SHORTGAME_CHECKBOX", "shortgame" },
{ "FOG_CHECKBOX", "fog" },
{ "ALLYBUILDRADIUS_CHECKBOX", "allybuild" },
{ "ALLOWCHEATS_CHECKBOX", "cheats" },
{ "CREEPS_CHECKBOX", "creeps" },
};
foreach (var kv in optionCheckboxes)
{
var checkbox = optionsBin.GetOrNull <CheckboxWidget>(kv.Key);
if (checkbox != null)
{
var option = new CachedTransform <Session.Global, Session.LobbyOptionState>(
gs => gs.LobbyOptions[kv.Value]);
var visible = new CachedTransform <Session.Global, bool>(
gs => gs.LobbyOptions.ContainsKey(kv.Value));
checkbox.IsVisible = () => visible.Update(orderManager.LobbyInfo.GlobalSettings);
checkbox.IsChecked = () => option.Update(orderManager.LobbyInfo.GlobalSettings).Enabled;
checkbox.IsDisabled = () => configurationDisabled() ||
option.Update(orderManager.LobbyInfo.GlobalSettings).Locked;
checkbox.OnClick = () => orderManager.IssueOrder(Order.Command(
"option {0} {1}".F(kv.Value, !option.Update(orderManager.LobbyInfo.GlobalSettings).Enabled)));
}
}
var optionDropdowns = new Dictionary <string, string>()
{
{ "TECHLEVEL", "techlevel" },
{ "STARTINGUNITS", "startingunits" },
{ "STARTINGCASH", "startingcash" },
{ "DIFFICULTY", "difficulty" },
{ "GAMESPEED", "gamespeed" }
};
var allOptions = new CachedTransform <MapPreview, LobbyOption[]>(
mapPreview => mapPreview.Rules.Actors["player"].TraitInfos <ILobbyOptions>()
.Concat(mapPreview.Rules.Actors["world"].TraitInfos <ILobbyOptions>())
.SelectMany(t => t.LobbyOptions(mapPreview.Rules))
.ToArray());
foreach (var kv in optionDropdowns)
{
var dropdown = optionsBin.GetOrNull <DropDownButtonWidget>(kv.Key + "_DROPDOWNBUTTON");
if (dropdown != null)
{
var optionValue = new CachedTransform <Session.Global, Session.LobbyOptionState>(
gs => gs.LobbyOptions[kv.Value]);
var option = new CachedTransform <MapPreview, LobbyOption>(
mapPreview => allOptions.Update(mapPreview).FirstOrDefault(o => o.Id == kv.Value));
var getOptionLabel = new CachedTransform <string, string>(id =>
{
string value;
if (id == null || !option.Update(map).Values.TryGetValue(id, out value))
{
return("Not Available");
}
return(value);
});
dropdown.GetText = () => getOptionLabel.Update(optionValue.Update(orderManager.LobbyInfo.GlobalSettings).Value);
dropdown.IsVisible = () => option.Update(map) != null;
dropdown.IsDisabled = () => configurationDisabled() ||
optionValue.Update(orderManager.LobbyInfo.GlobalSettings).Locked;
dropdown.OnMouseDown = _ =>
{
Func <KeyValuePair <string, string>, ScrollItemWidget, ScrollItemWidget> setupItem = (c, template) =>
{
Func <bool> isSelected = () => optionValue.Update(orderManager.LobbyInfo.GlobalSettings).Value == c.Key;
Action onClick = () => orderManager.IssueOrder(Order.Command("option {0} {1}".F(kv.Value, c.Key)));
var item = ScrollItemWidget.Setup(template, isSelected, onClick);
item.Get <LabelWidget>("LABEL").GetText = () => c.Value;
return(item);
};
var options = option.Update(map).Values;
dropdown.ShowDropDown("LABEL_DROPDOWN_TEMPLATE", options.Count() * 30, options, setupItem);
};
var label = optionsBin.GetOrNull(kv.Key + "_DESC");
if (label != null)
{
label.IsVisible = () => option.Update(map) != null;
}
}
}
var disconnectButton = lobby.Get <ButtonWidget>("DISCONNECT_BUTTON");
disconnectButton.OnClick = () => { Ui.CloseWindow(); onExit(); };
if (skirmishMode)
{
disconnectButton.Text = "Back";
}
var globalChat = Game.LoadWidget(null, "LOBBY_GLOBALCHAT_PANEL", lobby.Get("GLOBALCHAT_ROOT"), new WidgetArgs());
var globalChatInput = globalChat.Get <TextFieldWidget>("CHAT_TEXTFIELD");
globalChat.IsVisible = () => chatPanel == ChatPanelType.Global;
var globalChatTab = lobby.Get <ButtonWidget>("GLOBALCHAT_TAB");
globalChatTab.IsHighlighted = () => chatPanel == ChatPanelType.Global;
globalChatTab.OnClick = () =>
{
chatPanel = ChatPanelType.Global;
globalChatInput.TakeKeyboardFocus();
};
var globalChatLabel = globalChatTab.Text;
globalChatTab.GetText = () =>
{
if (globalChatUnreadMessages == 0 || chatPanel == ChatPanelType.Global)
{
return(globalChatLabel);
}
return(globalChatLabel + " ({0})".F(globalChatUnreadMessages));
};
globalChatLastReadMessages = Game.GlobalChat.History.Count(m => m.Type == ChatMessageType.Message);
var lobbyChat = lobby.Get("LOBBYCHAT");
lobbyChat.IsVisible = () => chatPanel == ChatPanelType.Lobby;
chatLabel = lobby.Get <LabelWidget>("LABEL_CHATTYPE");
var chatTextField = lobby.Get <TextFieldWidget>("CHAT_TEXTFIELD");
chatTextField.TakeKeyboardFocus();
chatTextField.OnEnterKey = () =>
{
if (chatTextField.Text.Length == 0)
{
return(true);
}
// Always scroll to bottom when we've typed something
lobbyChatPanel.ScrollToBottom();
orderManager.IssueOrder(Order.Chat(teamChat, chatTextField.Text));
chatTextField.Text = "";
return(true);
};
chatTextField.OnTabKey = () =>
{
var previousText = chatTextField.Text;
chatTextField.Text = tabCompletion.Complete(chatTextField.Text);
chatTextField.CursorPosition = chatTextField.Text.Length;
if (chatTextField.Text == previousText)
{
return(SwitchTeamChat());
}
else
{
return(true);
}
};
chatTextField.OnEscKey = () => { chatTextField.Text = ""; return(true); };
var lobbyChatTab = lobby.Get <ButtonWidget>("LOBBYCHAT_TAB");
lobbyChatTab.IsHighlighted = () => chatPanel == ChatPanelType.Lobby;
lobbyChatTab.OnClick = () =>
{
chatPanel = ChatPanelType.Lobby;
chatTextField.TakeKeyboardFocus();
};
var lobbyChatLabel = lobbyChatTab.Text;
lobbyChatTab.GetText = () =>
{
if (lobbyChatUnreadMessages == 0 || chatPanel == ChatPanelType.Lobby)
{
return(lobbyChatLabel);
}
return(lobbyChatLabel + " ({0})".F(lobbyChatUnreadMessages));
};
lobbyChatPanel = lobby.Get <ScrollPanelWidget>("CHAT_DISPLAY");
chatTemplate = lobbyChatPanel.Get("CHAT_TEMPLATE");
lobbyChatPanel.RemoveChildren();
var settingsButton = lobby.GetOrNull <ButtonWidget>("SETTINGS_BUTTON");
if (settingsButton != null)
{
settingsButton.OnClick = () => Ui.OpenWindow("SETTINGS_PANEL", new WidgetArgs
{
{ "onExit", DoNothing },
{ "worldRenderer", worldRenderer }
});
}
// Add a bot on the first lobbyinfo update
if (skirmishMode)
{
addBotOnMapLoad = true;
}
}
protected override Player CreatePlayer(Ruleset ruleset)
{
Mods.Value = Mods.Value.Concat(new[] { ruleset.GetAutoplayMod() }).ToArray();
return(base.CreatePlayer(ruleset));
}
public CatchLegacyDifficultyCalculator(Ruleset ruleset, WorkingBeatmap beatmap)
: base(ruleset, beatmap)
{
}
public void RulesetLoaded(Ruleset rules, ActorInfo ai)
{
ThumpDamageWeaponInfo = rules.Weapons[ThumpDamageWeapon.ToLowerInvariant()];
DetonationWeaponInfo = rules.Weapons[DetonationWeapon.ToLowerInvariant()];
}
protected virtual Player CreatePlayer(Ruleset ruleset) => new Player
{
AllowPause = false,
AllowLeadIn = false,
AllowResults = false,
};
public RushBeatmapConverter(IBeatmap beatmap, Ruleset ruleset)
: base(beatmap, ruleset)
{
}
IEnumerable <LobbyOption> ILobbyOptions.LobbyOptions(Ruleset rules)
{
yield return(new LobbyBooleanOption("cheats", CheckboxLabel, CheckboxDescription, CheckboxVisible, CheckboxDisplayOrder, CheckboxEnabled, CheckboxLocked));
}
public IngameChatLogic(Widget widget, OrderManager orderManager, World world, Ruleset modRules)
{
this.orderManager = orderManager;
this.modRules = modRules;
chatTraits = world.WorldActor.TraitsImplementing <INotifyChat>().ToArray();
var players = world.Players.Where(p => p != world.LocalPlayer && !p.NonCombatant && !p.IsBot);
disableTeamChat = world.LocalPlayer == null || world.LobbyInfo.IsSinglePlayer || !players.Any(p => p.IsAlliedWith(world.LocalPlayer));
teamChat = !disableTeamChat;
tabCompletion.Commands = chatTraits.OfType <ChatCommands>().SelectMany(x => x.Commands.Keys).ToList();
tabCompletion.Names = orderManager.LobbyInfo.Clients.Select(c => c.Name).Distinct().ToList();
var chatPanel = (ContainerWidget)widget;
chatOverlay = chatPanel.Get <ContainerWidget>("CHAT_OVERLAY");
chatOverlayDisplay = chatOverlay.Get <ChatDisplayWidget>("CHAT_DISPLAY");
chatOverlay.Visible = false;
chatChrome = chatPanel.Get <ContainerWidget>("CHAT_CHROME");
chatChrome.Visible = true;
var chatMode = chatChrome.Get <ButtonWidget>("CHAT_MODE");
chatMode.GetText = () => teamChat ? "Team" : "All";
chatMode.OnClick = () => teamChat ^= true;
chatMode.IsDisabled = () => disableTeamChat;
chatText = chatChrome.Get <TextFieldWidget>("CHAT_TEXTFIELD");
chatText.OnEnterKey = () =>
{
var team = teamChat && !disableTeamChat;
if (chatText.Text != "")
{
if (!chatText.Text.StartsWith("/"))
{
orderManager.IssueOrder(Order.Chat(team, chatText.Text.Trim()));
}
else
if (chatTraits != null)
{
var text = chatText.Text.Trim();
foreach (var trait in chatTraits)
{
trait.OnChat(orderManager.LocalClient.Name, text);
}
}
}
chatText.Text = "";
CloseChat();
return(true);
};
chatText.OnTabKey = () =>
{
var previousText = chatText.Text;
chatText.Text = tabCompletion.Complete(chatText.Text);
chatText.CursorPosition = chatText.Text.Length;
if (chatText.Text == previousText)
{
return(SwitchTeamChat());
}
else
{
return(true);
}
};
chatText.OnEscKey = () => { CloseChat(); return(true); };
var chatClose = chatChrome.Get <ButtonWidget>("CHAT_CLOSE");
chatClose.OnClick += CloseChat;
chatPanel.OnKeyPress = e =>
{
if (e.Event == KeyInputEvent.Up)
{
return(false);
}
if (!chatChrome.IsVisible() && (e.Key == Keycode.RETURN || e.Key == Keycode.KP_ENTER))
{
OpenChat();
return(true);
}
return(false);
};
chatScrollPanel = chatChrome.Get <ScrollPanelWidget>("CHAT_SCROLLPANEL");
chatTemplate = chatScrollPanel.Get <ContainerWidget>("CHAT_TEMPLATE");
chatScrollPanel.RemoveChildren();
chatScrollPanel.ScrollToBottom();
foreach (var chatLine in orderManager.ChatCache)
{
AddChatLine(chatLine.Color, chatLine.Name, chatLine.Text, true);
}
orderManager.AddChatLine += AddChatLineWrapper;
Game.BeforeGameStart += UnregisterEvents;
CloseChat();
}
protected override TestPlayer CreatePlayer(Ruleset ruleset) => new TestPlayer(true, false);
/// <summary> /// Creates a <see cref="IBeatmapConverter"/> to convert a <see cref="IBeatmap"/> for a specified <see cref="Ruleset"/>. /// </summary> /// <param name="beatmap">The <see cref="IBeatmap"/> to be converted.</param> /// <param name="ruleset">The <see cref="Ruleset"/> for which <paramref name="beatmap"/> should be converted.</param> /// <returns>The applicable <see cref="IBeatmapConverter"/>.</returns> protected virtual IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap, Ruleset ruleset) => ruleset.CreateBeatmapConverter(beatmap);
public static void SetupEditableSlotWidget(Widget parent, Session.Slot s, Session.Client c, OrderManager orderManager, Ruleset rules)
{
var slot = parent.Get <DropDownButtonWidget>("SLOT_OPTIONS");
slot.IsVisible = () => true;
slot.IsDisabled = () => orderManager.LocalClient.IsReady;
slot.GetText = () => c != null ? c.Name : s.Closed ? "Closed" : "Open";
slot.OnMouseDown = _ => ShowSlotDropDown(rules, slot, s, c, orderManager);
// Ensure Name selector (if present) is hidden
var name = parent.GetOrNull("NAME");
if (name != null)
{
name.IsVisible = () => false;
}
}
public GameplayState(Score score, Ruleset ruleset, WorkingBeatmap beatmap)
{
Score = score;
Ruleset = ruleset;
Beatmap = beatmap;
}
protected override DrawableRuleset <OsuHitObject> CreateDrawableRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList <Mod> mods = null) => new DrawableOsuEditorRuleset(ruleset, beatmap, mods);
public HitokoriBeatmapConverter(IBeatmap beatmap, Ruleset ruleset) : base(beatmap, ruleset)
{
} // TODO untangle beatmap
public OsuSettingsSubsection(Ruleset ruleset)
: base(ruleset)
{
}
void CheckTrait(Action <string> emitError, ActorInfo actorInfo, TraitInfo traitInfo, Ruleset rules)
{
var actualType = traitInfo.GetType();
foreach (var field in actualType.GetFields())
{
if (field.HasAttribute <ActorReferenceAttribute>())
{
CheckActorReference(emitError, actorInfo, traitInfo, field, rules.Actors,
field.GetCustomAttributes <ActorReferenceAttribute>(true)[0]);
}
if (field.HasAttribute <WeaponReferenceAttribute>())
{
CheckWeaponReference(emitError, actorInfo, traitInfo, field, rules.Weapons);
}
if (field.HasAttribute <VoiceSetReferenceAttribute>())
{
CheckVoiceReference(emitError, actorInfo, traitInfo, field, rules.Voices);
}
}
}
protected override Player CreatePlayer(Ruleset ruleset)
{
SelectedMods.Value = SelectedMods.Value.Concat(new[] { ruleset.GetAutoplayMod() }).ToArray();
return(new ScoreAccessiblePlayer());
}
protected HitObjectComposer(Ruleset ruleset)
{
Ruleset = ruleset;
}
/// <summary>
/// Construct a drawable ruleset for the provided ruleset.
/// </summary>
/// <remarks>
/// Can be overridden to add editor-specific logical changes to a <see cref="Ruleset"/>'s standard <see cref="DrawableRuleset{TObject}"/>.
/// For example, hit animations or judgement logic may be changed to give a better editor user experience.
/// </remarks>
/// <param name="ruleset">The ruleset used to construct its drawable counterpart.</param>
/// <param name="beatmap">The loaded beatmap.</param>
/// <param name="mods">The mods to be applied.</param>
/// <returns>An editor-relevant <see cref="DrawableRuleset{TObject}"/>.</returns>
protected virtual DrawableRuleset <TObject> CreateDrawableRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList <Mod> mods = null)
=> (DrawableRuleset <TObject>)ruleset.CreateDrawableRulesetWith(beatmap, mods);
protected override Player CreatePlayer(Ruleset ruleset)
{
SelectedMods.Value = new[] { ruleset.GetAutoplayMod() };
return(new TestReplayPlayer(false));
}
public OsuHitObjectComposer(Ruleset ruleset)
: base(ruleset)
{
}
