public Synchronizer(SyncType type, long seed)
{
_type = type;
_rng = new RNG(seed);
_index = 0;
_state = null;
_pinned = false;
}
public void Uniform()
{
var rng = new RNG(1234);
Assert.AreEqual(4, rng.Uniform(0, 10));
Assert.AreEqual(6, rng.Uniform(0, 10));
Assert.AreEqual(9, rng.Uniform(0, 10));
}
public void Next()
{
var rng = new RNG(0xffffffff);
Assert.AreEqual(130063606, rng.Next());
Assert.AreEqual(3003295397, rng.Next());
Assert.AreEqual(3870020839, rng.Next());
}
/// <summary>
/// Calculates the index of the next block item to execute.
/// </summary>
/// <param name="blockItemCount">The number of items in the block.</param>
/// <param name="rng">The random number generator to use with index calculation.</param>
/// <returns></returns>
public int NextIndex(int blockItemCount, RNG rng)
{
// Use synchronizer if available
if (Sync != null)
{
return Sync.NextItem(blockItemCount);
}
return rng.Next(blockItemCount);
}
/// <summary>
/// Calculates the index of the next block item to execute.
/// </summary>
/// <param name="blockItemCount">The number of items in the block.</param>
/// <param name="rng">The random number generator to use with index calculation.</param>
/// <returns></returns>
public int NextIndex(int blockItemCount, RNG rng)
{
if (Chance < 100 && rng.NextDouble(0, 100) > Chance)
{
return -1; // Skip the block
}
// Use synchronizer if available
if (Sync != null)
{
return Sync.NextItem(blockItemCount);
}
return rng.Next(blockItemCount);
}
public App()
: base(RNG.XOrShift1024())
{
}
public void GridSystem()
{
AddUntilStep("The room is load", () => _room.IsLoaded);
AddStep("Add some objects", () =>
{
for (int y = 0; y < Grid.CellSize; y++)
{
for (int x = 0; x < Grid.CellSize; x++)
{
var spike = RNG.NextBool();
Grid.Add(new DrawableGameObject(new GameObject
{
Hitbox = spike ? "Triangle" : "Square"
}
)
{
X = x,
Y = y,
Size = new Vector2(Grid.CellSize),
Origin = Anchor.Centre,
GameObject =
{
Texture = spike ? "BasicSpike" : "BasicTile"
},
Colour = new Color4(
Math.Max(0.5f, RNG.NextSingle()),
Math.Max(0.5f, RNG.NextSingle()),
Math.Max(0.5f, RNG.NextSingle()),
1),
Rotation = 90 * RNG.Next(0, 4)
});
}
}
/*
* _grid.Add(new DrawableGameObject(new GameObject())
* {
* X = 1,
* Y = 1,
* Hitbox = new Box()
* });
*
* _grid.Add(new DrawableGameObject(new GameObject())
* {
* X = 1,
* Y = 2,
* Hitbox = new Box()
* });
*
* _grid.Add(new DrawableGameObject(new GameObject())
* {
* X = 5,
* Y = 2,
* Hitbox = new Box()
* });
*
* _grid.Add(new Box
* {
* X = 7,
* Y = 3,
* Size = new Vector2(16)
* });
*
* _grid.Add(new Box
* {
* X = 13,
* Y = 18,
* Size = new Vector2(16)
* });*/
});
AddAssert("Objects added", () => Grid.Objects.Any());
AddAssert("Tiles added", () => Grid.Objects.Any(o => o is DrawableGameObject obj && obj.GameObject.Texture == "BasicTile"));
AddAssert("Spikes added", () => Grid.Objects.Any(o => o is DrawableGameObject obj && obj.GameObject.Texture == "BasicSpike"));
AddStep("Render grid to room", () => Grid.Render(_room));
AddStep("Render room", () => _room.Render());
}
public void HandlePacket(IPacketHandlerContext ctx)
{
if (ctx.HasSession)
{
return;
}
if (!long.TryParse(ctx.Args.ElementAtOrDefault(1), out long userId) || userId < 1)
{
return;
}
string token = ctx.Args.ElementAtOrDefault(2);
if (string.IsNullOrEmpty(token))
{
return;
}
Action <Exception> exceptionHandler = new Action <Exception>(ex => {
Logger.Debug($@"<{ctx.Connection.RemoteAddress}> Auth fail: {ex.Message}");
ctx.Connection.Send(new AuthFailPacket(AuthFailReason.AuthInvalid));
ctx.Connection.Close();
});
DataProvider.UserAuthClient.AttemptAuth(
new UserAuthRequest(userId, token, ctx.Connection.RemoteAddress),
res => {
DataProvider.BanClient.CheckBan(res.UserId, ctx.Connection.RemoteAddress, ban => {
if (ban.IsPermanent || ban.Expires > DateTimeOffset.Now)
{
ctx.Connection.Send(new AuthFailPacket(AuthFailReason.Banned, ban));
ctx.Connection.Close();
return;
}
IUser user = Users.Connect(res);
// Enforce a maximum amount of connections per user
if (Sessions.GetAvailableSessionCount(user) < 1)
{
ctx.Connection.Send(new AuthFailPacket(AuthFailReason.MaxSessions));
ctx.Connection.Close();
return;
}
ISession sess = Sessions.Create(ctx.Connection, user);
sess.SendPacket(new WelcomeMessagePacket(Sender, $@"Welcome to Flashii Chat, {user.UserName}!"));
if (File.Exists(WELCOME))
{
IEnumerable <string> lines = File.ReadAllLines(WELCOME).Where(x => !string.IsNullOrWhiteSpace(x));
string line = lines.ElementAtOrDefault(RNG.Next(lines.Count()));
if (!string.IsNullOrWhiteSpace(line))
{
sess.SendPacket(new WelcomeMessagePacket(Sender, line));
}
}
IChannel chan = Channels.DefaultChannel;
bool shouldJoin = !ChannelUsers.HasUser(chan, user);
if (shouldJoin)
{
// ChannelUsers?
//chan.SendPacket(new UserConnectPacket(DateTimeOffset.Now, user));
//ctx.Chat.DispatchEvent(this, new UserConnectEvent(chan, user));
}
sess.SendPacket(new AuthSuccessPacket(user, chan, sess, Version, Messages.TextMaxLength));
ChannelUsers.GetUsers(chan, u => sess.SendPacket(new ContextUsersPacket(u.Except(new[] { user }).OrderByDescending(u => u.Rank))));
Messages.GetMessages(chan, m => {
foreach (IMessage msg in m)
{
sess.SendPacket(new ContextMessagePacket(msg));
}
});
Channels.GetChannels(user.Rank, c => sess.SendPacket(new ContextChannelsPacket(c)));
if (shouldJoin)
{
ChannelUsers.JoinChannel(chan, sess);
}
}, exceptionHandler);
},
exceptionHandler
);
}
public async Task Dice(int di, int va)
{
if (va > Context.User.Dust.Dust)
{
Reply($"@{Context.User.Nick} Ставка не может превышать ваше количесво пыли!");
return;
}
if (BotEntry.RedstoneDust.ContainsKey(Context.User.Username))
{
if (di > 5 && di < 37)
{
var value = RNG.Next(1, 7) + RNG.Next(1, 7) + RNG.Next(1, 7) + RNG.Next(1, 7) + RNG.Next(1, 7) + RNG.Next(1, 7);
if (Context.User.Dust.Dust > 80)
{
if (18 > value && value < 26)
{
if (RNG.Next(0, 101) < 55)
{
if (RNG.Next(0, 101) > 45)
{
value /= 2;
}
else
{
value /= 3;
}
if (value < 7)
{
value = RNG.Next(6, 10);
}
}
}
}
if (value == di)
{
Context.User.Dust.Dust += va * 3;
Reply($"Бросает кости... На костях выпадает сумма {value}... Вы угадали и выйграли {va * 3} пыли! @{Context.User.Nick} Ваш баланс теперь {Context.User.Dust}");
return;
//delay = CommandDelay;
}
else if ((value == di + 1 || value == di - 1) && Context.User.Dust.Dust < 80)
{
Context.User.Dust.Dust += va;
Reply($"Бросает кости... На костях выпадает сумма {value}... Вы почти угадали и казино пошло на уступку. Вы выйграли {va} пыли! @{Context.User.Nick} Ваш баланс теперь {Context.User.Dust}");
return;
}
else
{
Context.User.Dust.Dust -= va;
Reply($"Бросает кости... На костях выпадает сумма {value}... Вы проиграли {va} пыли! @{Context.User.Nick} Ваш баланс теперь {Context.User.Dust}");
return;
//delay = CommandDelay;
}
}
else
{
Reply($"@{Context.User.Nick} Вне диапазона: 6 <= {di} => 36");
return;
}
}
}
protected override TestDrawableHitCircle CreateDrawableHitCircle(HitCircle circle, bool auto)
{
var drawableHitObject = base.CreateDrawableHitCircle(circle, auto);
Scheduler.AddDelayed(() => drawableHitObject.TriggerJudgement(),
drawableHitObject.HitObject.StartTime - (drawableHitObject.HitObject.HitWindows.HalfWindowFor(HitResult.Miss) + RNG.Next(0, 300)) - Time.Current);
return(drawableHitObject);
}
public static RantDictionaryEntry PickEntry(this IEnumerable<RantDictionaryEntry> enumerable, RNG rng)
{
var array = enumerable as RantDictionaryEntry[] ?? enumerable.ToArray();
return array.Length > 0 ? array[rng.Next(array.Length)] : null;
}
public OsuPatternFileHandler()
{
CollectionFolderName = RNG.RandomString(20);
}
/// <summary>
/// https://github.com/Itseez/opencv_extra/blob/master/learning_opencv_v2/ch13_ex13_1.cpp
/// </summary>
private static void example01()
{
using (var window = new Window("Clusters", flags: WindowMode.AutoSize | WindowMode.FreeRatio))
{
const int maxClusters = 5;
var rng = new RNG(state: (ulong)DateTime.Now.Ticks);
for (; ; )
{
var clustersCount = rng.Uniform(a: 2, b: maxClusters + 1);
var samplesCount = rng.Uniform(a: 1, b: 1001);
var points = new Mat(rows: samplesCount, cols: 1, type: MatType.CV_32FC2);
clustersCount = Math.Min(clustersCount, samplesCount);
var img = new Mat(rows: 500, cols: 500, type: MatType.CV_8UC3, s: Scalar.All(0));
// generate random sample from multi-gaussian distribution
for (var k = 0; k < clustersCount; k++)
{
var pointChunk = points.RowRange(
startRow: k * samplesCount / clustersCount,
endRow: (k == clustersCount - 1)
? samplesCount
: (k + 1) * samplesCount / clustersCount);
var center = new Point
{
X = rng.Uniform(a: 0, b: img.Cols),
Y = rng.Uniform(a: 0, b: img.Rows)
};
rng.Fill(
mat: pointChunk,
distType: DistributionType.Normal,
a: new Scalar(center.X, center.Y),
b: new Scalar(img.Cols * 0.05f, img.Rows * 0.05f));
}
Cv2.RandShuffle(dst: points, iterFactor: 1, rng: rng);
var labels = new Mat();
var centers = new Mat(rows: clustersCount, cols: 1, type: points.Type());
Cv2.Kmeans(
data: points,
k: clustersCount,
bestLabels: labels,
criteria: new TermCriteria(CriteriaType.Epsilon | CriteriaType.Iteration, 10, 1.0),
attempts: 3,
flags: KMeansFlag.PpCenters,
centers: centers);
Scalar[] colors =
{
new Scalar(0, 0, 255),
new Scalar(0, 255, 0),
new Scalar(255, 100, 100),
new Scalar(255, 0, 255),
new Scalar(0, 255, 255)
};
for (var i = 0; i < samplesCount; i++)
{
var clusterIdx = labels.At<int>(i);
Point ipt = points.At<Point2f>(i);
Cv2.Circle(
img: img,
center: ipt,
radius: 2,
color: colors[clusterIdx],
lineType: LineType.AntiAlias,
thickness: Cv.FILLED);
}
window.Image = img;
var key = (char)Cv2.WaitKey();
if (key == 27 || key == 'q' || key == 'Q') // 'ESC'
{
break;
}
}
}
}
/// <summary>
/// Queries the RantDictionary according to the specified criteria and returns a random match.
/// </summary>
/// <param name="rng">The random number generator to randomize the match with.</param>
/// <param name="query">The search criteria to use.</param>
/// <param name="syncState">The state object to use for carrier synchronization.</param>
/// <returns></returns>
internal string Query(RNG rng, Query query, QueryState syncState)
{
RantDictionaryTable table;
return !_tables.TryGetValue(query.Name, out table)
? "[Missing Table]"
: table.Query(this, rng, query, syncState);
}
public int CreateUser(string email, string pass, string user)
{
SurveyPortalDBDataContext sql = new SurveyPortalDBDataContext();
try
{
var check = (from u in sql.users where u.username == user select u).FirstOrDefault();
if (check.username.ToLower() == user.ToLower())
{
return 2;
}
}
catch (Exception e) { }
try
{
var check = (from u in sql.users where u.email == email select u).FirstOrDefault();
if (check.email.ToLower() == email.ToLower())
{
return 3;
}
}
catch (Exception e) { }
user adduser = new user
{
email = email,
password = pass,
username = user,
isEnabled = false
};
sql.users.InsertOnSubmit(adduser);
try
{
sql.SubmitChanges();
RNG rng = new RNG();
string activation = "";
for(int i = 0; i < 16; i++)
{
int type = rng.NextRandom(0, 1);
char c;
if(type == 0)
{
c = (char)rng.NextRandom(48, 57);
}
else
{
c = (char)rng.NextRandom(65, 90);
}
activation += c;
}
validationcode valid = new validationcode
{
userid = adduser.id,
code = activation
};
sql.validationcodes.InsertOnSubmit(valid);
try
{
sql.SubmitChanges();
}
catch(Exception n)
{
}
SMTPHandler smtp = new SMTPHandler();
smtp.SendActivation(activation, email, user, pass);
return 0;
}
catch (Exception e)
{
return 1;
}
}
internal RantDictionaryEntry GetEntry(Carrier carrier, int subtypeIndex, IEnumerable<RantDictionaryEntry> pool, RNG rng)
{
if (carrier == null) return pool.PickEntry(rng);
RantDictionaryEntry result = null;
// Handle match carriers
foreach(var match in carrier.GetCarriers(CarrierComponent.Match))
if (_matchTable.TryGetValue(match, out result)) return result;
// Handle associative carriers
foreach(var assoc in carrier.GetCarriers(CarrierComponent.Associative))
{
if (_assocTable.TryGetValue(assoc, out result))
pool = pool.Where(e => e.AssociatesWith(result));
break;
}
// Handle match-associative carriers
foreach(var massoc in carrier.GetCarriers(CarrierComponent.MatchAssociative))
{
if (_matchTable.TryGetValue(massoc, out result))
pool = pool.Where(e => e.AssociatesWith(result));
break;
}
// Handle unique carriers
foreach(var unique in carrier.GetCarriers(CarrierComponent.Unique))
{
HashSet<RantDictionaryEntry> usedSet;
if (!_uniqueTable.TryGetValue(unique, out usedSet))
{
usedSet = _uniqueTable[unique] = new HashSet<RantDictionaryEntry>();
}
pool = pool.Except(usedSet);
}
// Handle match-unique carriers
foreach (var munique in carrier.GetCarriers(CarrierComponent.Unique))
{
if (_matchTable.TryGetValue(munique, out result))
pool = pool.Where(e => e != result);
}
// Handle relational carriers
foreach(var relate in carrier.GetCarriers(CarrierComponent.Relational))
{
if (_assocTable.TryGetValue(relate, out result))
pool = pool.Where(e => e.RelatesWith(result));
}
// Handle match-relational carriers
foreach (var relate in carrier.GetCarriers(CarrierComponent.MatchRelational))
{
if (_matchTable.TryGetValue(relate, out result))
pool = pool.Where(e => e.RelatesWith(result));
}
// Handle dissociative carriers
foreach (var relate in carrier.GetCarriers(CarrierComponent.Dissociative))
{
if (_assocTable.TryGetValue(relate, out result))
pool = pool.Where(e => !e.RelatesWith(result));
}
// Handle match-dissociative carriers
foreach (var relate in carrier.GetCarriers(CarrierComponent.MatchDissociative))
{
if (_matchTable.TryGetValue(relate, out result))
pool = pool.Where(e => !e.RelatesWith(result));
}
// Handle divergent carriers
foreach (var diverge in carrier.GetCarriers(CarrierComponent.Divergent))
{
if (_assocTable.TryGetValue(diverge, out result))
pool = pool.Where(e => e.DivergesFrom(result));
}
// Handle match-divergent carriers
foreach (var diverge in carrier.GetCarriers(CarrierComponent.MatchDivergent))
{
if (_matchTable.TryGetValue(diverge, out result))
pool = pool.Where(e => e.DivergesFrom(result));
}
result = pool.PickEntry(rng);
// Handle rhyme carrier
foreach (var rhyme in carrier.GetCarriers(CarrierComponent.Rhyme))
{
_<RantDictionaryTerm, HashSet<RantDictionaryEntry>> rhymeState;
if (!_rhymeTable.TryGetValue(rhyme, out rhymeState))
{
result = pool
.Where(e => !Util.IsNullOrWhiteSpace(e.Terms[subtypeIndex].Pronunciation))
.PickEntry(rng);
_rhymeTable[rhyme] = _.Create(result.Terms[subtypeIndex], new HashSet<RantDictionaryEntry>(new[] { result }));
break;
}
result =
pool.Except(rhymeState.Item2)
.Where(e =>
!Util.IsNullOrWhiteSpace(e.Terms[subtypeIndex].Pronunciation) &&
_rhymer.Rhyme(rhymeState.Item1, e.Terms[subtypeIndex]))
.PickEntry(rng);
if (result != null) rhymeState.Item2.Add(result);
break; // Ignore any extra rhyme carriers
}
if (result == null) return result;
foreach (var a in carrier.GetCarriers(CarrierComponent.Associative))
if (!_assocTable.ContainsKey(a)) _assocTable[a] = result;
foreach (var a in carrier.GetCarriers(CarrierComponent.Dissociative))
if (!_assocTable.ContainsKey(a)) _assocTable[a] = result;
foreach (var a in carrier.GetCarriers(CarrierComponent.Divergent))
if (!_assocTable.ContainsKey(a)) _assocTable[a] = result;
foreach (var a in carrier.GetCarriers(CarrierComponent.Relational))
if (!_assocTable.ContainsKey(a)) _assocTable[a] = result;
foreach (var unique in carrier.GetCarriers(CarrierComponent.Unique))
_uniqueTable[unique].Add(result);
foreach (var match in carrier.GetCarriers(CarrierComponent.Match))
{
_matchTable[match] = result;
break;
}
return result;
}
internal string Query(RantDictionary dictionary, RNG rng, Query query, QueryState syncState)
{
var index = String.IsNullOrEmpty(query.Subtype) ? 0 : GetSubtypeIndex(query.Subtype);
if (index == -1) return "[Bad Subtype]";
var pool = query.ClassFilter.IsEmpty
? _entries
: _entries.Where(e => query.ClassFilter.Test(e, query.Exclusive));
if (_hidden.Any())
{
var hide = _hidden.Where(hc => !query.ClassFilter.AllowsClass(hc))
.Except(dictionary.IncludedHiddenClasses);
pool = pool.Where(e => !hide.Any(e.ContainsClass));
}
if (query.RegexFilters.Any())
pool = query.RegexFilters.Aggregate(pool, (current, regex) => current.Where(e => regex.Item1 == regex.Item2.IsMatch(e.Terms[index].Value)));
if (query.SyllablePredicate != null)
pool = pool.Where(e => query.SyllablePredicate.Test(e.Terms[index].SyllableCount));
if (!pool.Any()) return MissingTerm;
return syncState.GetEntry(query.Carrier, index, pool, rng)?[index] ?? MissingTerm;
}
public Sandbox(RantEngine engine, RantPattern pattern, RNG rng, int sizeLimit = 0)
{
_engine = engine;
_format = engine.Format;
_sizeLimit = new Limit(sizeLimit);
_mainOutput = new ChannelWriter(_format, _sizeLimit);
_outputs = new Stack<ChannelWriter>();
_outputs.Push(_mainOutput);
_rng = rng;
_startingGen = rng.Generation;
_pattern = pattern;
_objects = new ObjectStack(engine.Objects);
_blocks = new Stack<BlockState>();
_matches = new Stack<Match>();
_queryState = new QueryState();
_subroutineArgs = new Stack<Dictionary<string, RantAction>>();
_syncManager = new SyncManager(this);
_blockManager = new BlockManager();
_scriptObjectStack = new Stack<object>();
_stopwatch = new Stopwatch();
}
public TestSceneScoresContainer()
{
TestScoresContainer scoresContainer;
Child = new Container
{
Anchor = Anchor.TopCentre,
Origin = Anchor.TopCentre,
RelativeSizeAxes = Axes.Both,
Width = 0.8f,
Children = new Drawable[]
{
new Box
{
RelativeSizeAxes = Axes.Both,
Colour = Color4.Black,
},
scoresContainer = new TestScoresContainer(),
}
};
var allScores = new APILegacyScores
{
Scores = new List <APILegacyScoreInfo>
{
new APILegacyScoreInfo
{
User = new User
{
Id = 6602580,
Username = @"waaiiru",
Country = new Country
{
FullName = @"Spain",
FlagName = @"ES",
},
},
Mods = new[]
{
new OsuModDoubleTime().Acronym,
new OsuModHidden().Acronym,
new OsuModFlashlight().Acronym,
new OsuModHardRock().Acronym,
},
Rank = ScoreRank.XH,
PP = 200,
MaxCombo = 1234,
TotalScore = 1234567890,
Accuracy = 1,
},
new APILegacyScoreInfo
{
User = new User
{
Id = 4608074,
Username = @"Skycries",
Country = new Country
{
FullName = @"Brazil",
FlagName = @"BR",
},
},
Mods = new[]
{
new OsuModDoubleTime().Acronym,
new OsuModHidden().Acronym,
new OsuModFlashlight().Acronym,
},
Rank = ScoreRank.S,
PP = 190,
MaxCombo = 1234,
TotalScore = 1234789,
Accuracy = 0.9997,
},
new APILegacyScoreInfo
{
User = new User
{
Id = 1014222,
Username = @"eLy",
Country = new Country
{
FullName = @"Japan",
FlagName = @"JP",
},
},
Mods = new[]
{
new OsuModDoubleTime().Acronym,
new OsuModHidden().Acronym,
},
Rank = ScoreRank.B,
PP = 180,
MaxCombo = 1234,
TotalScore = 12345678,
Accuracy = 0.9854,
},
new APILegacyScoreInfo
{
User = new User
{
Id = 1541390,
Username = @"Toukai",
Country = new Country
{
FullName = @"Canada",
FlagName = @"CA",
},
},
Mods = new[]
{
new OsuModDoubleTime().Acronym,
},
Rank = ScoreRank.C,
PP = 170,
MaxCombo = 1234,
TotalScore = 1234567,
Accuracy = 0.8765,
},
new APILegacyScoreInfo
{
User = new User
{
Id = 7151382,
Username = @"Mayuri Hana",
Country = new Country
{
FullName = @"Thailand",
FlagName = @"TH",
},
},
Rank = ScoreRank.D,
PP = 160,
MaxCombo = 1234,
TotalScore = 123456,
Accuracy = 0.6543,
},
}
};
var myBestScore = new APILegacyUserTopScoreInfo
{
Score = new APILegacyScoreInfo
{
User = new User
{
Id = 7151382,
Username = @"Mayuri Hana",
Country = new Country
{
FullName = @"Thailand",
FlagName = @"TH",
},
},
Rank = ScoreRank.D,
PP = 160,
MaxCombo = 1234,
TotalScore = 123456,
Accuracy = 0.6543,
},
Position = 1337,
};
var oneScore = new APILegacyScores
{
Scores = new List <APILegacyScoreInfo>
{
new APILegacyScoreInfo
{
User = new User
{
Id = 6602580,
Username = @"waaiiru",
Country = new Country
{
FullName = @"Spain",
FlagName = @"ES",
},
},
Mods = new[]
{
new OsuModDoubleTime().Acronym,
new OsuModHidden().Acronym,
new OsuModFlashlight().Acronym,
new OsuModHardRock().Acronym,
},
Rank = ScoreRank.XH,
PP = 200,
MaxCombo = 1234,
TotalScore = 1234567890,
Accuracy = 1,
}
}
};
foreach (var s in allScores.Scores)
{
s.Statistics = new Dictionary <string, int>
{
{ "count_300", RNG.Next(2000) },
{ "count_100", RNG.Next(2000) },
{ "count_50", RNG.Next(2000) },
{ "count_miss", RNG.Next(2000) }
};
}
AddStep("Load all scores", () =>
{
allScores.UserScore = null;
scoresContainer.Scores = allScores;
});
AddStep("Load null scores", () => scoresContainer.Scores = null);
AddStep("Load only one score", () => scoresContainer.Scores = oneScore);
AddStep("Load scores with my best", () =>
{
allScores.UserScore = myBestScore;
scoresContainer.Scores = allScores;
});
}
public override void Reset()
{
base.Reset();
createArea(scrollDir = Direction.Vertical);
AddStep("Vertical", delegate { createArea(scrollDir = Direction.Vertical); });
AddStep("Horizontal", delegate { createArea(scrollDir = Direction.Horizontal); });
AddStep("Both", createAreaBoth);
AddStep("Dragger Anchor 1", delegate { scroll.ScrollDraggerAnchor = scrollDir == Direction.Vertical ? Anchor.TopRight : Anchor.BottomLeft; });
AddStep("Dragger Anchor 2", delegate { scroll.ScrollDraggerAnchor = Anchor.TopLeft; });
AddStep("Dragger Visible", delegate { scroll.ScrollDraggerVisible = !scroll.ScrollDraggerVisible; });
AddStep("Dragger Overlap", delegate { scroll.ScrollDraggerOverlapsContent = !scroll.ScrollDraggerOverlapsContent; });
boxCreator?.Cancel();
boxCreator = Scheduler.AddDelayed(delegate
{
if (Parent == null)
{
return;
}
Box box;
Container container = new Container
{
Size = new Vector2(80, 80),
Children = new[]
{
box = new Box
{
RelativeSizeAxes = Axes.Both,
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
Colour = new Color4(RNG.NextSingle(), RNG.NextSingle(), RNG.NextSingle(), 1)
}
}
};
flow.Add(container);
container.FadeInFromZero(1000);
using (container.BeginDelayedSequence(RNG.Next(0, 20000), true))
{
container.FadeOutFromOne(4000);
box.RotateTo((RNG.NextSingle() - 0.5f) * 90, 4000);
box.ScaleTo(0.5f, 4000);
container.Expire();
}
}, 100, true);
}
public void TestBeatmapDownloadingStates()
{
AddStep("set to no map", () => Client.ChangeBeatmapAvailability(BeatmapAvailability.NotDownloaded()));
AddStep("set to downloading map", () => Client.ChangeBeatmapAvailability(BeatmapAvailability.Downloading(0)));
checkProgressBarVisibility(true);
AddRepeatStep("increment progress", () =>
{
float progress = this.ChildrenOfType <ParticipantPanel>().Single().User.BeatmapAvailability.DownloadProgress ?? 0;
Client.ChangeBeatmapAvailability(BeatmapAvailability.Downloading(progress + RNG.NextSingle(0.1f)));
}, 25);
AddAssert("progress bar increased", () => this.ChildrenOfType <ProgressBar>().Single().Current.Value > 0);
AddStep("set to importing map", () => Client.ChangeBeatmapAvailability(BeatmapAvailability.Importing()));
checkProgressBarVisibility(false);
AddStep("set to available", () => Client.ChangeBeatmapAvailability(BeatmapAvailability.LocallyAvailable()));
}
public double GetValue()
{
return(RNG.GetInverseGamma(this.Shape, this.Scale));
}
public void TestManyUsers()
{
AddStep("add many users", () =>
{
for (int i = 0; i < 20; i++)
{
Client.AddUser(new APIUser
{
Id = i,
Username = $"User {i}",
RulesetsStatistics = new Dictionary <string, UserStatistics>
{
{
Ruleset.Value.ShortName,
new UserStatistics {
GlobalRank = RNG.Next(1, 100000),
}
}
},
CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c3.jpg",
});
Client.ChangeUserState(i, (MultiplayerUserState)RNG.Next(0, (int)MultiplayerUserState.Results + 1));
if (RNG.NextBool())
{
var beatmapState = (DownloadState)RNG.Next(0, (int)DownloadState.LocallyAvailable + 1);
switch (beatmapState)
{
case DownloadState.NotDownloaded:
Client.ChangeUserBeatmapAvailability(i, BeatmapAvailability.NotDownloaded());
break;
case DownloadState.Downloading:
Client.ChangeUserBeatmapAvailability(i, BeatmapAvailability.Downloading(RNG.NextSingle()));
break;
case DownloadState.Importing:
Client.ChangeUserBeatmapAvailability(i, BeatmapAvailability.Importing());
break;
}
}
}
});
}
public RCSource(string name, Point3D position, double amplitude, RNG random, bool on = true, double mean = 0.0, double std = 1.0)
: base(name, position, amplitude, on)
{
randomsource = random;
randomparams = new[] { mean, std };
}
public CharacterSelection()
{
for (int i = 0; i < characters.Length; i++)
{
characters[i] = new SpriteSheetContext("Clawdia_Direction_Anim-Sheet.png", 8, 8)
{
RenderSize = Vector.Create(64, 64),
};
//don't tint the first character
if (i > 0)
{
characters[i].RenderColor = new Annex.Data.RGBA((byte)RNG.Next(255), (byte)RNG.Next(255), (byte)RNG.Next(255));
}
}
this.Events.AddEvent("ChooseCharacter", PriorityType.INPUT, ChooseCharacter, 500);
}
private void buildTest()
{
Add(new Container
{
Padding = new MarginPadding(25f),
RelativeSizeAxes = Axes.Both,
Children = new Drawable[]
{
fillContainer = new FillFlowContainer
{
RelativeSizeAxes = Axes.Both,
AutoSizeAxes = Axes.None,
},
new Box
{
Anchor = Anchor.CentreLeft,
Origin = Anchor.Centre,
RelativeSizeAxes = Axes.Y,
Size = new Vector2(3, 1),
Colour = Color4.HotPink,
},
new Box
{
Anchor = Anchor.CentreRight,
Origin = Anchor.Centre,
RelativeSizeAxes = Axes.Y,
Size = new Vector2(3, 1),
Colour = Color4.HotPink,
},
new Box
{
Anchor = Anchor.TopCentre,
Origin = Anchor.Centre,
RelativeSizeAxes = Axes.X,
Size = new Vector2(1, 3),
Colour = Color4.HotPink,
},
new Box
{
Anchor = Anchor.BottomCentre,
Origin = Anchor.Centre,
RelativeSizeAxes = Axes.X,
Size = new Vector2(1, 3),
Colour = Color4.HotPink,
}
}
});
AddToggleStep("Rotate Container", state => { fillContainer.RotateTo(state ? 45f : 0, 1000); });
AddToggleStep("Scale Container", state => { fillContainer.ScaleTo(state ? 1.2f : 1f, 1000); });
AddToggleStep("Shear Container", state => { fillContainer.Shear = state ? new Vector2(0.5f, 0f) : new Vector2(0f, 0f); });
AddToggleStep("Center Container Anchor", state => { fillContainer.Anchor = state ? Anchor.Centre : Anchor.TopLeft; });
AddToggleStep("Center Container Origin", state => { fillContainer.Origin = state ? Anchor.Centre : Anchor.TopLeft; });
AddToggleStep("Autosize Container", state =>
{
if (state)
{
fillContainer.RelativeSizeAxes = Axes.None;
fillContainer.AutoSizeAxes = Axes.Both;
}
else
{
fillContainer.AutoSizeAxes = Axes.None;
fillContainer.RelativeSizeAxes = Axes.Both;
fillContainer.Width = 1;
fillContainer.Height = 1;
}
});
AddToggleStep("Rotate children", state =>
{
if (state)
{
foreach (var child in fillContainer.Children)
{
child.RotateTo(45f, 1000);
}
}
else
{
foreach (var child in fillContainer.Children)
{
child.RotateTo(0f, 1000);
}
}
});
AddToggleStep("Shear children", state =>
{
if (state)
{
foreach (var child in fillContainer.Children)
{
child.Shear = new Vector2(0.2f, 0.2f);
}
}
else
{
foreach (var child in fillContainer.Children)
{
child.Shear = Vector2.Zero;
}
}
});
AddToggleStep("Scale children", state =>
{
if (state)
{
foreach (var child in fillContainer.Children)
{
child.ScaleTo(1.25f, 1000);
}
}
else
{
foreach (var child in fillContainer.Children)
{
child.ScaleTo(1f, 1000);
}
}
});
AddToggleStep("Randomly scale children", state =>
{
if (state)
{
foreach (var child in fillContainer.Children)
{
child.ScaleTo(RNG.NextSingle(1, 2), 1000);
}
}
else
{
foreach (var child in fillContainer.Children)
{
child.ScaleTo(1f, 1000);
}
}
});
AddToggleStep("Randomly set child origins", state =>
{
if (state)
{
foreach (var child in fillContainer.Children)
{
switch (RNG.Next(9))
{
case 0:
child.Origin = Anchor.TopLeft;
break;
case 1:
child.Origin = Anchor.TopCentre;
break;
case 2:
child.Origin = Anchor.TopRight;
break;
case 3:
child.Origin = Anchor.CentreLeft;
break;
case 4:
child.Origin = Anchor.Centre;
break;
case 5:
child.Origin = Anchor.CentreRight;
break;
case 6:
child.Origin = Anchor.BottomLeft;
break;
case 7:
child.Origin = Anchor.BottomCentre;
break;
case 8:
child.Origin = Anchor.BottomRight;
break;
}
}
}
else
{
foreach (var child in fillContainer.Children)
{
child.Origin = originDropdown.Current.Value;
}
}
});
AddToggleStep("Stop adding children", state => { doNotAddChildren = state; });
scheduledAdder?.Cancel();
scheduledAdder = Scheduler.AddDelayed(
() =>
{
if (fillContainer.Parent == null)
{
scheduledAdder.Cancel();
}
if (doNotAddChildren)
{
fillContainer.Invalidate();
}
if (fillContainer.Children.Count < 1000 && !doNotAddChildren)
{
fillContainer.Add(new Container
{
Anchor = childAnchor,
Origin = childOrigin,
AutoSizeAxes = Axes.Both,
Children = new Drawable[]
{
new Box
{
Width = 50,
Height = 50,
Colour = Color4.White
},
new SpriteText
{
Colour = Color4.Black,
RelativePositionAxes = Axes.Both,
Position = new Vector2(0.5f, 0.5f),
Origin = Anchor.Centre,
Text = fillContainer.Children.Count.ToString()
}
}
});
}
},
100,
true
);
}
public override Action GetAction(Suggestion suggestion, float currentHP)
{
var AttackChance = 3;
var DefendChance = 3;
var BuffChance = 3;
var DoNothingChance = 1;
var FleeChance = 1;
switch (suggestion)
{
case Suggestion.Attack:
AttackChance += 1;
break;
case Suggestion.Defend:
DefendChance += 1;
break;
case Suggestion.Support:
BuffChance += 1;
break;
case Suggestion.Whatever:
AttackChance += 2;
DefendChance += 2;
BuffChance += 2;
DoNothingChance += 2;
FleeChance += 2;
break;
default:
break;
}
if (currentHP < 0.15)
{
FleeChance += 2;
//TODO Atacar Treinadores
}
var rand = RNG.GetRandom();
var roll = rand.Next(0, AttackChance + DefendChance + BuffChance + DoNothingChance + FleeChance);
if (roll < AttackChance)
{
return(Action.Attack);
}
if (roll > AttackChance && roll < AttackChance + DefendChance)
{
return(Action.Defend);
}
if (roll > AttackChance + DefendChance && roll < AttackChance + DefendChance + BuffChance)
{
return(Action.Buff);
}
if (roll > AttackChance + DefendChance + BuffChance && roll < AttackChance + DefendChance + BuffChance + DoNothingChance)
{
return(Action.DoNothing);
}
else
{
return(Action.Flee);
}
}
public void OnInit()
{
startingPosition = Transformation.Position;
rotateMultiplier = RNG.Range(MinRotateSpeedMult, MaxRotateSpeedMult);
bobDirection = RotateSpeed.Normalized();
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(RNG obj)
{
return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr);
}
public TestCaseScoreCounter()
{
int numerator = 0, denominator = 0;
ScoreCounter score = new ScoreCounter(7)
{
Origin = Anchor.TopRight,
Anchor = Anchor.TopRight,
TextSize = 40,
Margin = new MarginPadding(20),
};
Add(score);
ComboCounter comboCounter = new StandardComboCounter
{
Origin = Anchor.BottomLeft,
Anchor = Anchor.BottomLeft,
Margin = new MarginPadding(10),
TextSize = 40,
};
Add(comboCounter);
PercentageCounter accuracyCounter = new PercentageCounter
{
Origin = Anchor.TopRight,
Anchor = Anchor.TopRight,
Position = new Vector2(-20, 60),
};
Add(accuracyCounter);
StarCounter stars = new StarCounter
{
Origin = Anchor.BottomLeft,
Anchor = Anchor.BottomLeft,
Position = new Vector2(20, -160),
Count = 5,
};
Add(stars);
SpriteText starsLabel = new SpriteText
{
Origin = Anchor.BottomLeft,
Anchor = Anchor.BottomLeft,
Position = new Vector2(20, -190),
Text = stars.Count.ToString("0.00"),
};
Add(starsLabel);
AddStep(@"Reset all", delegate
{
score.Current.Value = 0;
comboCounter.Current.Value = 0;
numerator = denominator = 0;
accuracyCounter.SetFraction(0, 0);
stars.Count = 0;
starsLabel.Text = stars.Count.ToString("0.00");
});
AddStep(@"Hit! :D", delegate
{
score.Current.Value += 300 + (ulong)(300.0 * (comboCounter.Current > 0 ? comboCounter.Current - 1 : 0) / 25.0);
comboCounter.Increment();
numerator++;
denominator++;
accuracyCounter.SetFraction(numerator, denominator);
});
AddStep(@"miss...", delegate
{
comboCounter.Current.Value = 0;
denominator++;
accuracyCounter.SetFraction(numerator, denominator);
});
AddStep(@"Alter stars", delegate
{
stars.Count = RNG.NextSingle() * (stars.StarCount + 1);
starsLabel.Text = stars.Count.ToString("0.00");
});
AddStep(@"Stop counters", delegate
{
score.StopRolling();
comboCounter.StopRolling();
accuracyCounter.StopRolling();
stars.StopAnimation();
});
}
/// <summary>
/// Returns a random generated name
/// </summary>
private string GetName()
{
int random = RNG.Next(0, Names.Count);
return(Names[random]);
}
private void load()
{
managerUpdated = beatmaps.ItemUpdated.GetBoundCopy();
managerUpdated.BindValueChanged(beatmapUpdated);
managerRemoved = beatmaps.ItemRemoved.GetBoundCopy();
managerRemoved.BindValueChanged(beatmapRemoved);
beatmapSets.AddRange(beatmaps.GetAllUsableBeatmapSets(IncludedDetails.Minimal, true).OrderBy(_ => RNG.Next()));
// Todo: These binds really shouldn't be here, but are unlikely to cause any issues for now.
// They are placed here for now since some tests rely on setting the beatmap _and_ their hierarchies inside their load(), which runs before the MusicController's load().
beatmap.BindValueChanged(beatmapChanged, true);
mods.BindValueChanged(_ => ResetTrackAdjustments(), true);
}
public override void SetUpSteps()
{
AddStep("set local user", () => ((DummyAPIAccess)API).LocalUser.Value = LookupCache.GetUserAsync(1).Result);
AddStep("create leaderboard", () =>
{
leaderboard?.Expire();
OsuScoreProcessor scoreProcessor;
Beatmap.Value = CreateWorkingBeatmap(Ruleset.Value);
var playableBeatmap = Beatmap.Value.GetPlayableBeatmap(Ruleset.Value);
var multiplayerUsers = new List <MultiplayerRoomUser>();
foreach (var user in users)
{
SpectatorClient.StartPlay(user, Beatmap.Value.BeatmapInfo.OnlineBeatmapID ?? 0);
var roomUser = OnlinePlayDependencies.Client.AddUser(new User {
Id = user
}, true);
roomUser.MatchState = new TeamVersusUserState
{
TeamID = RNG.Next(0, 2)
};
multiplayerUsers.Add(roomUser);
}
Children = new Drawable[]
{
scoreProcessor = new OsuScoreProcessor(),
};
scoreProcessor.ApplyBeatmap(playableBeatmap);
LoadComponentAsync(leaderboard = new MultiplayerGameplayLeaderboard(scoreProcessor, multiplayerUsers.ToArray())
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
}, gameplayLeaderboard =>
{
LoadComponentAsync(new MatchScoreDisplay
{
Team1Score = { BindTarget = leaderboard.TeamScores[0] },
Team2Score = { BindTarget = leaderboard.TeamScores[1] }
}, Add);
LoadComponentAsync(gameplayScoreDisplay = new GameplayMatchScoreDisplay
{
Anchor = Anchor.BottomCentre,
Origin = Anchor.BottomCentre,
Team1Score = { BindTarget = leaderboard.TeamScores[0] },
Team2Score = { BindTarget = leaderboard.TeamScores[1] }
}, Add);
Add(gameplayLeaderboard);
});
});
AddUntilStep("wait for load", () => leaderboard.IsLoaded);
AddUntilStep("wait for user population", () => Client.CurrentMatchPlayingUserIds.Count > 0);
}
protected override void Update()
{
base.Update();
particleContainer.Add(new MedalParticle(RNG.Next(0, 359)));
}
public void ApplyToRulesetContainer(RulesetContainer <ManiaHitObject> rulesetContainer)
{
int availableColumns = ((ManiaRulesetContainer)rulesetContainer).AvailableColumns;
var shuffledColumns = Enumerable.Range(0, availableColumns).OrderBy(item => RNG.Next()).ToList();
rulesetContainer.Objects.OfType <ManiaHitObject>().ForEach(h => h.Column = shuffledColumns[h.Column]);
}
public TestSceneGameplayCursor()
{
gameplayBeatmap = new GameplayBeatmap(CreateBeatmap(new OsuRuleset().RulesetInfo));
AddStep("change background colour", () =>
{
background?.Expire();
Add(background = new Box
{
RelativeSizeAxes = Axes.Both,
Depth = float.MaxValue,
Colour = new Colour4(RNG.NextSingle(), RNG.NextSingle(), RNG.NextSingle(), 1)
});
});
AddSliderStep("circle size", 0f, 10f, 0f, val =>
{
config.Set(OsuSetting.AutoCursorSize, true);
gameplayBeatmap.BeatmapInfo.BaseDifficulty.CircleSize = val;
Scheduler.AddOnce(recreate);
});
AddStep("test cursor container", recreate);
void recreate() => SetContents(() => new OsuInputManager(new OsuRuleset().RulesetInfo)
{
Child = new OsuCursorContainer()
});
}
public static void randBytes(byte[] buf, int length)
{
RNG.GetBytes(buf, length);
}
public ParticlePart(double availableDuration)
{
distance = RNG.NextSingle(0.5f);
duration = RNG.NextDouble(availableDuration / 3, availableDuration);
direction = RNG.NextSingle(0, MathF.PI * 2);
}
private void addRandomPrivateChannel() =>
channelTabControl.AddChannel(new Channel(new APIUser
{
Id = RNG.Next(1000, 10000000),
Username = "******" + RNG.Next(1000)
}));
public OsuPatternFileHandler(string basePath)
{
CollectionFolderName = RNG.RandomString(20);
BasePath = basePath;
EnsureCollectionFolderExists();
}
public Randomizer(RNG randomsource, int dimxbegin = 0, int dimxend = 0, int dimybegin = 0, int dimyend = 0, int dimzbegin = 0, int dimzend = 0, double mean = 0.5, double std = 0.5)
{
this.randomsource = randomsource;
this.dimxbegin = dimxbegin;
this.dimxend = dimxend;
this.dimybegin = dimybegin;
this.dimyend = dimyend;
this.dimzbegin = dimzbegin;
this.dimzend = dimzend;
this.mean = mean;
this.std = std;
}
private void OnUpdateUse()
{
try
{
if (GameManager.IsPaused || this.useSleeper)
{
return;
}
var abilities = this.recoveryAbilities.Where(x => this.toggler.IsEnabled(x.Name))
.OrderBy(x => this.toggler.GetPriority(x.Name))
.ToList();
if (abilities.Count == 0)
{
return;
}
if (this.TakeBottleFromStash(abilities))
{
this.useSleeper.Sleep(RNG.Randomize(0.15f, 0.05f));
return;
}
foreach (var ability in abilities)
{
if (!ability.CanBeCasted())
{
continue;
}
if (this.SwitchPowerTreads(ability))
{
this.useSleeper.Sleep(RNG.Randomize(0.1f, 0.02f));
return;
}
if (this.DropItems(ability))
{
this.useSleeper.Sleep(
this.IsAllItemsDropped(ability) ? RNG.Randomize(0.1f, 0.05f) : RNG.Randomize(this.DefaultDelay, 0.05f));
return;
}
if (ability.UseAbility())
{
this.useSleeper.Sleep(ability.Delay + RNG.Randomize(this.DefaultDelay, 0.05f));
return;
}
}
if (abilities.Any(x => !x.CanPickUpItems()))
{
return;
}
if (this.PickUpUsable(abilities))
{
this.useSleeper.Sleep(RNG.Randomize(0.3f, 0.05f));
return;
}
this.pickSleeper.Sleep(0.1f);
this.useAbilitiesHandler.IsEnabled = false;
this.pickUpItemsHandler.IsEnabled = true;
}
catch (Exception e)
{
Logger.Error(e);
}
}
protected override void UpdateInitialTransforms()
{
base.UpdateInitialTransforms();
const float end_scale = 0.6f;
const float random_scale_range = 1.6f;
ScaleContainer.ScaleTo(HitObject.Scale * (end_scale + random_scale_range * RNG.NextSingle()))
.Then().ScaleTo(HitObject.Scale * end_scale, HitObject.TimePreempt);
ScaleContainer.RotateTo(getRandomAngle())
.Then()
.RotateTo(getRandomAngle(), HitObject.TimePreempt);
float getRandomAngle() => 180 *(RNG.NextSingle() * 2 - 1);
}
public TestSceneChannelTabControl()
{
SpriteText currentText;
Add(new Container
{
RelativeSizeAxes = Axes.X,
Origin = Anchor.Centre,
Anchor = Anchor.Centre,
Children = new Drawable[]
{
channelTabControl = new TestTabControl
{
RelativeSizeAxes = Axes.X,
Origin = Anchor.Centre,
Anchor = Anchor.Centre,
Height = 50
},
new Box
{
Colour = Color4.Black.Opacity(0.1f),
RelativeSizeAxes = Axes.X,
Height = 50,
Depth = -1,
Origin = Anchor.Centre,
Anchor = Anchor.Centre,
}
}
});
Add(new Container
{
Origin = Anchor.TopLeft,
Anchor = Anchor.TopLeft,
Children = new Drawable[]
{
currentText = new OsuSpriteText
{
Text = "Currently selected channel:"
}
}
});
channelTabControl.OnRequestLeave += channel => channelTabControl.RemoveChannel(channel);
channelTabControl.Current.ValueChanged += channel => currentText.Text = "Currently selected channel: " + channel.NewValue;
AddStep("Add random private channel", addRandomPrivateChannel);
AddAssert("There is only one channels", () => channelTabControl.Items.Count == 2);
AddRepeatStep("Add 3 random private channels", addRandomPrivateChannel, 3);
AddAssert("There are four channels", () => channelTabControl.Items.Count == 5);
AddStep("Add random public channel", () => addChannel(RNG.Next().ToString()));
AddRepeatStep("Select a random channel", () =>
{
List <Channel> validChannels = channelTabControl.Items.Where(c => !(c is ChannelSelectorTabItem.ChannelSelectorTabChannel)).ToList();
channelTabControl.SelectChannel(validChannels[RNG.Next(0, validChannels.Count)]);
}, 20);
Channel channelBefore = null;
AddStep("set first channel", () => channelTabControl.SelectChannel(channelBefore = channelTabControl.Items.First(c => !(c is ChannelSelectorTabItem.ChannelSelectorTabChannel))));
AddStep("select selector tab", () => channelTabControl.SelectChannel(channelTabControl.Items.Single(c => c is ChannelSelectorTabItem.ChannelSelectorTabChannel)));
AddAssert("selector tab is active", () => channelTabControl.ChannelSelectorActive.Value);
AddAssert("check channel unchanged", () => channelBefore == channelTabControl.Current.Value);
AddStep("set second channel", () => channelTabControl.SelectChannel(channelTabControl.Items.GetNext(channelBefore)));
AddAssert("selector tab is inactive", () => !channelTabControl.ChannelSelectorActive.Value);
AddUntilStep("remove all channels", () =>
{
foreach (var item in channelTabControl.Items.ToList())
{
if (item is ChannelSelectorTabItem.ChannelSelectorTabChannel)
{
continue;
}
channelTabControl.RemoveChannel(item);
return(false);
}
return(true);
});
AddAssert("selector tab is active", () => channelTabControl.ChannelSelectorActive.Value);
}
public static char SelectFromRanges(string rangeString, RNG rng)
{
if (String.IsNullOrEmpty(rangeString)) return '?';
var list = new List<_<char, char, int>>(); // <min, max, weight>
var chars = rangeString.GetEnumerator();
char a, b;
bool stall = false;
while (stall || chars.MoveNext())
{
stall = false;
if (Char.IsWhiteSpace(chars.Current)) continue;
if (!Char.IsLetterOrDigit(a = chars.Current)) return '?';
if (!chars.MoveNext())
{
list.Add(_.Create(a, a, 1));
break;
}
if (chars.Current == '-')
{
if (!chars.MoveNext()) return '?';
if (!Char.IsLetterOrDigit(b = chars.Current)) return '?';
if (Char.IsLetter(a) != Char.IsLetter(b) || Char.IsUpper(a) != Char.IsUpper(b)) return '?';
list.Add(_.Create(a < b ? a : b, a > b ? a : b, Math.Abs(b - a) + 1));
continue;
}
list.Add(_.Create(a, a, 1));
stall = true;
}
if (!list.Any()) return '?';
int wSelect = rng.Next(0, list.Sum(r => r.Item3)) + 1;
var ranges = list.GetEnumerator();
while (ranges.MoveNext())
{
if (wSelect > ranges.Current.Item3)
{
wSelect -= ranges.Current.Item3;
}
else
{
break;
}
}
return Convert.ToChar(rng.Next(ranges.Current.Item1, ranges.Current.Item2 + 1));
}
