public void getChunkAt(IChunkProvider ichunkprovider, int i, int j) {
Chunk chunk = this.getOrCreateChunk(i, j);
if (!chunk.done) {
chunk.done = true;
if (this.chunkProvider != null) {
this.chunkProvider.getChunkAt(ichunkprovider, i, j);
// CraftBukkit start
BlockSand.instaFall = true;
Random random = new Random();
random.setSeed(world.getSeed());
long xRand = random.nextLong() / 2L * 2L + 1L;
long zRand = random.nextLong() / 2L * 2L + 1L;
random.setSeed((long) i * xRand + (long) j * zRand ^ world.getSeed());
org.bukkit.World world = this.world.getWorld();
if (world != null) {
for (org.bukkit.generator.BlockPopulator populator : world.getPopulators()) {
populator.populate(world, random, chunk.bukkitChunk);
}
}
BlockSand.instaFall = false;
this.world
.getServer()
.getPluginManager()
.callEvent(new org.bukkit.event.world.ChunkPopulateEvent(chunk.bukkitChunk));
// CraftBukkit end
chunk.e();
}
}
}
/** java.util.Random#setSeed(long) */
public void test_setSeedJ() {
// Test for method void java.util.Random.setSeed(long)
long[] randomArray = new long[100];
boolean someDifferent = false;
final long firstSeed = 1000;
long aLong, anotherLong, yetAnotherLong;
Random aRandom = new Random();
Random anotherRandom = new Random();
Random yetAnotherRandom = new Random();
aRandom.setSeed(firstSeed);
anotherRandom.setSeed(firstSeed);
for (int counter = 0; counter < randomArray.length; counter++) {
aLong = aRandom.nextLong();
anotherLong = anotherRandom.nextLong();
assertTrue(
"Two randoms with same seeds gave differing nextLong values", aLong == anotherLong);
yetAnotherLong = yetAnotherRandom.nextLong();
randomArray[counter] = aLong;
if (aLong != yetAnotherLong) someDifferent = true;
}
assertTrue("Two randoms with the different seeds gave the same chain of values", someDifferent);
aRandom.setSeed(firstSeed);
for (int counter = 0; counter < randomArray.length; counter++)
assertTrue(
"Reseting a random to its old seed did not result in the same chain of values as it gave before",
aRandom.nextLong() == randomArray[counter]);
}
public void generateMapGen(
Block[] blocks,
byte[] metadata,
Long seed,
World world,
WorldChunkManagerRTG cmr,
Random mapRand,
int chunkX,
int chunkY,
OpenSimplexNoise simplex,
CellNoise cell,
float noise[]) {
int k = 5;
mapRand.setSeed(seed);
long l = (mapRand.nextLong() / 2L) * 2L + 1L;
long l1 = (mapRand.nextLong() / 2L) * 2L + 1L;
for (int baseX = chunkX - k; baseX <= chunkX + k; baseX++) {
for (int baseY = chunkY - k; baseY <= chunkY + k; baseY++) {
mapRand.setSeed((long) baseX * l + (long) baseY * l1 ^ seed);
rMapGen(
blocks, metadata, world, cmr, mapRand, baseX, baseY, chunkX, chunkY, simplex, cell,
noise);
}
}
}
public void generate(IChunkProvider ichunkprovider, World world, int i, int j, Block blocks[]) {
int k = range;
worldObj = world;
rand.setSeed(worldObj.getSeed());
long l = (rand.nextLong() / 2L) * 2L + 1L;
long l1 = (rand.nextLong() / 2L) * 2L + 1L;
for (int i1 = i - k; i1 <= i + k; i1++) {
for (int j1 = j - k; j1 <= j + k; j1++) {
rand.setSeed((long) i1 * l + (long) j1 * l1 ^ worldObj.getSeed());
recursiveGenerate(worldObj, i1, j1, i, j, blocks);
}
}
}
@Override
protected void postSubmit() throws Exception {
final Random randPoints = new Random();
final Random randModels = new Random();
final Pattern p = Pattern.compile("(\\d+) (\\d+) (\\d+)");
long[][] results = new long[NUM_POINTS][NUM_MODELS];
boolean[][] occurs = new boolean[NUM_POINTS][NUM_MODELS];
for (int i = 0; i < NUM_POINTS; i++) {
for (int j = 0; j < NUM_MODELS; j++) {
long actDotProd = 0;
randPoints.setSeed(SEED_POINTS + 1000 * (i + 1));
randModels.setSeed(SEED_MODELS + 1000 * (j + 1));
for (int z = 1; z <= NUM_FEATURES; z++) {
actDotProd += randPoints.nextInt(1000) * randModels.nextInt(100);
}
results[i][j] = actDotProd;
occurs[i][j] = false;
}
}
for (BufferedReader reader : getResultReader(this.resultPath)) {
String line = null;
while (null != (line = reader.readLine())) {
final Matcher m = p.matcher(line);
Assert.assertTrue(m.matches());
int modelId = Integer.parseInt(m.group(1));
int pointId = Integer.parseInt(m.group(2));
long expDotProd = Long.parseLong(m.group(3));
Assert.assertFalse(
"Dot product for record (" + pointId + ", " + modelId + ") occurs more than once",
occurs[pointId - 1][modelId - 1]);
Assert.assertEquals(
String.format("Bad product for (%04d, %04d)", pointId, modelId),
expDotProd,
results[pointId - 1][modelId - 1]);
occurs[pointId - 1][modelId - 1] = true;
}
}
for (int i = 0; i < NUM_POINTS; i++) {
for (int j = 0; j < NUM_MODELS; j++) {
Assert.assertTrue(
"Dot product for record (" + (i + 1) + ", " + (j + 1) + ") does not occur",
occurs[i][j]);
}
}
}
public void generate(World world, int x, int z, byte blockArray[]) {
Random rand = new Random();
rand.setSeed(world.getSeed());
int k = 8;
rand.setSeed(world.getSeed());
long l = (rand.nextLong() / 2L) * 2L + 1L;
long l1 = (rand.nextLong() / 2L) * 2L + 1L;
for (int i1 = x - k; i1 <= x + k; i1++) {
for (int j1 = z - k; j1 <= z + k; j1++) {
rand.setSeed((long) i1 * l + (long) j1 * l1 ^ world.getSeed());
func_868_a(world, rand, i1, j1, x, z, blockArray);
}
}
}
private void initOriginal() throws Exception {
int size = 500000;
float x;
float y;
float z;
float a;
Coord3d[] points = new Coord3d[size];
Color[] colors = new Color[size];
Random r = new Random();
r.setSeed(0);
for (int i = 0; i < size; i++) {
x = r.nextFloat() - 0.5f;
y = r.nextFloat() - 0.5f;
z = r.nextFloat() - 0.5f;
points[i] = new Coord3d(x, y, z);
a = 0.25f;
colors[i] = new Color(x, y, z, a);
}
Scatter scatter = new Scatter(points, colors);
chart = AWTChartComponentFactory.chart(Quality.Advanced, "newt");
chart.getScene().add(scatter);
}
private void b(World world, Random random, int i, int j) {
random.setSeed(world.getSeed());
long k = random.nextLong();
long l = random.nextLong();
long i1 = (long) i * k;
long j1 = (long) j * l;
random.setSeed(i1 ^ j1 ^ world.getSeed());
int k1 = i * 16 + 8 - 29;
int l1 = j * 16 + 8 - 29;
EnumDirection enumdirection = EnumDirectionLimit.HORIZONTAL.a(random);
this.a.add(new WorldGenMonumentPiece1(random, k1, l1, enumdirection));
this.c();
this.d = true;
}
static synchronized Random getRandom(String algorithm, Double seed) throws ExpressionException {
algorithm = algorithm.toLowerCase();
Random result = randoms.get(algorithm);
if (result == null || !seed.isNaN()) {
if (CFMXCompat.ALGORITHM_NAME.equalsIgnoreCase(algorithm)) {
result = new Random();
} else {
try {
result = SecureRandom.getInstance(algorithm);
} catch (NoSuchAlgorithmException e) {
throw new ExpressionException(
"random algorithm [" + algorithm + "] is not installed on the system",
e.getMessage());
}
}
if (!seed.isNaN()) result.setSeed(seed.longValue());
randoms.put(algorithm, result);
}
return result;
}
/** Populate a single chunk if needed. */
private void populateChunk(int x, int z, boolean force) {
GlowChunk chunk = getChunk(x, z);
// cancel out if it's already populated
if (chunk.isPopulated()) {
return;
}
// cancel out if the 3x3 around it isn't available
for (int x2 = x - 1; x2 <= x + 1; ++x2) {
for (int z2 = z - 1; z2 <= z + 1; ++z2) {
if (!getChunk(x2, z2).isLoaded() && (!force || !loadChunk(x2, z2, true))) {
return;
}
}
}
// it might have loaded since before, so check again that it's not already populated
if (chunk.isPopulated()) {
return;
}
chunk.setPopulated(true);
Random random = new Random(world.getSeed());
long xRand = random.nextLong() / 2 * 2 + 1;
long zRand = random.nextLong() / 2 * 2 + 1;
random.setSeed((long) x * xRand + (long) z * zRand ^ world.getSeed());
for (BlockPopulator p : world.getPopulators()) {
p.populate(world, random, chunk);
}
EventFactory.callEvent(new ChunkPopulateEvent(chunk));
}
public Chunk provideChunk(int i, int j) {
field_913_j.setSeed((long) i * 0x4f9939f508L + (long) j * 0x1ef1565bd5L);
byte abyte0[] = new byte[32768];
field_4179_v =
worldObj_16
.getWorldChunkManager()
.loadBlockGeneratorData(field_4179_v, i * 16, j * 16, 16, 16);
double ad[] = BWG4WorldChunkManager.temperature;
generateTerrain(i, j, abyte0, field_4179_v, ad);
replaceBlocksForBiome(i, j, abyte0, field_4179_v);
field_902_u.generate(this, worldObj_16, i, j, abyte0);
if (mapFeaturesEnabled) {
strongholdGenerator.generate(this, worldObj_16, i, j, abyte0);
}
Chunk chunk = new Chunk(worldObj_16, abyte0, i, j);
byte abyte1[] = chunk.getBiomeArray();
for (int k = 0; k < abyte1.length; k++) {
abyte1[k] = (byte) field_4179_v[k].biomeID;
}
chunk.generateSkylightMap();
return chunk;
}
public static double RandomDouble(double min, double max) {
if (!isRand) {
rand.setSeed((new Date()).getTime());
isRand = true;
}
return min + rand.nextDouble() * (max - min);
}
private void init(int height, int width) {
mRandom.setSeed(System.currentTimeMillis());
if ((height != mHeight) || (width != mWidth)) {
mGrid = new KruskalCell[height][width];
}
for (int i = 0; i < height; i++) {
for (int j = 0; j < width; j++) {
if (mGrid[i][j] == null) {
mGrid[i][j] = new KruskalCell(i, j);
}
mGrid[i][j].init();
}
}
Integer[] walls = new Integer[height * (width - 1) + width * (height - 1)];
for (int i = 0; i < walls.length; i++) {
walls[i] = i;
}
mWalls = Arrays.asList(walls);
Collections.shuffle(mWalls, mRandom);
this.mHeight = height;
this.mWidth = width;
}
@Test(groups = "1m")
public void testSumvsIntLinCombTest() {
Random rand = new Random();
for (int seed = 0; seed < 400; seed++) {
rand.setSeed(seed);
int n = 1 + rand.nextInt(6);
int min = -10 + rand.nextInt(20);
int max = min + rand.nextInt(20);
int[][] domains = DomainBuilder.buildFullDomains(n, min, max, rand, 1.0, false);
int[] coeffs = new int[n];
for (int i = 0; i < n; i++) {
coeffs[i] = -25 + rand.nextInt(50);
}
int lb = -50 + rand.nextInt(100);
int op = -1 + rand.nextInt(3);
Solver sum = sum(domains, coeffs, lb, op);
Solver intlincomb = intlincomb(domains, coeffs, lb, op);
sum.findAllSolutions();
intlincomb.findAllSolutions();
Assert.assertEquals(
sum.getMeasures().getSolutionCount(), intlincomb.getMeasures().getSolutionCount());
Assert.assertEquals(
sum.getMeasures().getNodeCount(), intlincomb.getMeasures().getNodeCount());
LoggerFactory.getLogger("test")
.info(
"({}) {}ms vs {}ms",
op,
sum.getMeasures().getTimeCount(),
intlincomb.getMeasures().getTimeCount());
}
}
@Override
protected int[] filterPixels(int width, int height, int[] inPixels, Rectangle transformedSpace) {
int[] outPixels = new int[width * height];
randomGenerator.setSeed(seed);
int w1 = width - 1;
int h1 = height - 1;
putPixel(0, 0, randomRGB(inPixels, 0, 0), outPixels, width);
putPixel(w1, 0, randomRGB(inPixels, w1, 0), outPixels, width);
putPixel(0, h1, randomRGB(inPixels, 0, h1), outPixels, width);
putPixel(w1, h1, randomRGB(inPixels, w1, h1), outPixels, width);
putPixel(w1 / 2, h1 / 2, randomRGB(inPixels, w1 / 2, h1 / 2), outPixels, width);
putPixel(0, h1 / 2, randomRGB(inPixels, 0, h1 / 2), outPixels, width);
putPixel(w1, h1 / 2, randomRGB(inPixels, w1, h1 / 2), outPixels, width);
putPixel(w1 / 2, 0, randomRGB(inPixels, w1 / 2, 0), outPixels, width);
putPixel(w1 / 2, h1, randomRGB(inPixels, w1 / 2, h1), outPixels, width);
int depth = 1;
while (doPixel(0, 0, width - 1, height - 1, outPixels, width, depth, 0)) depth++;
if (useColormap && colormap != null) {
int index = 0;
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
outPixels[index] = colormap.getColor((outPixels[index] & 0xff) / 255.0f);
index++;
}
}
}
return outPixels;
}
@Override
public void open() throws IOException {
LOG.info("Resetting count and seed; openingSynthSourceRandSize");
// resetting the seed
count = 0;
rand.setSeed(seed);
}
public Result getResult() throws OlapException {
// make result reproducable for testing purposes
random.setSeed(123427);
int cellCount = 1;
for (int i = 0; i < axes.length; i++) cellCount *= axes[i].getPositions().size();
Locale locale = super.getLocale();
if (locale == null) locale = Locale.getDefault();
DecimalFormat fmt = (DecimalFormat) DecimalFormat.getInstance(locale);
fmt.applyPattern("#,##0.00");
ArrayList cells = new ArrayList();
for (int i = 0; i < cellCount; i++) {
CellImpl c = new CellImpl();
if (false) {
c.setValue(new Integer(i));
c.setFormattedValue(Integer.toString(i));
} else {
double value = random.nextGaussian() * 100 + 1000;
c.setValue(new Double(value));
c.setFormattedValue(fmt.format(value));
}
addProperties(c, i);
cells.add(c);
}
ResultImpl res = new ResultImpl();
res.setAxes(axes);
res.setCells(cells);
res.setSlicer(slicer);
return res;
}
@Override
public void rMapGen(
Block[] blocks,
byte[] metadata,
World world,
WorldChunkManagerRTG cmr,
Random mapRand,
int baseX,
int baseY,
int chunkX,
int chunkY,
OpenSimplexNoise simplex,
CellNoise cell,
float noise[]) {
if (baseX % 4 == 0 && baseY % 4 == 0 && mapRand.nextInt(6) == 0) {
float river = cmr.getRiverStrength(baseX * 16, baseY * 16) + 1f;
if (river > 0.98f && cmr.isBorderlessAt(baseX * 16, baseY * 16)) {
long i1 = mapRand.nextLong() / 2L * 2L + 1L;
long j1 = mapRand.nextLong() / 2L * 2L + 1L;
mapRand.setSeed((long) chunkX * i1 + (long) chunkY * j1 ^ world.getSeed());
WorldGenVolcano.build(
blocks, metadata, world, mapRand, baseX, baseY, chunkX, chunkY, simplex, cell, noise);
}
}
}
public static double RandomDouble() {
if (!isRand) {
rand.setSeed((new Date()).getTime());
isRand = true;
}
return rand.nextDouble();
}
/** Returns a new Random that's seeded based on the world seed and the x,z position */
public static Random getRandom(World world, BlockPos pos) {
Random random = new Random(world.getSeed());
long l = ((random.nextLong() / 2L) * 2L) + 1L;
long l1 = ((random.nextLong() / 2L) * 2L) + 1L;
random.setSeed(((pos.getX() * l) + (pos.getZ() * l1)) ^ world.getSeed());
return random;
}
public static boolean RandomBoolean() {
if (!isRand) {
rand.setSeed((new Date()).getTime());
isRand = true;
}
return rand.nextBoolean();
}
@Override
protected double doUpdate(double durationSeconds, long sampleCounter) {
// Update phase in the wave
currentPhase += durationSeconds * frequency.get();
// Update noise value if needed
if (currentPhase >= 1) {
currentPhase -= 1;
// Update seed if needed
final double newSeed = seed.get();
if (currentSeed != newSeed) {
random.setSeed(Double.doubleToLongBits(newSeed));
currentSeed = newSeed;
}
// White noise
currentNoiseValue = random.nextDouble() * 2.0 - 1.0;
// Bring phase down if it gets too large
if (currentPhase > 100000) currentPhase -= 100000;
if (currentPhase > 1000) currentPhase -= 1000;
if (currentPhase > 100) currentPhase -= 100;
if (currentPhase > 10) currentPhase -= 10;
}
// Apply amplitude and offset
return amplitude.get() * currentNoiseValue + offset.get();
}
@Override
public Chunk provideChunk(int chunkX, int chunkZ) {
rand.setSeed(chunkX * 341873128712L + chunkZ * 132897987541L);
biomesForGeneration =
worldObj
.getBiomeProvider()
.loadBlockGeneratorData(biomesForGeneration, chunkX * 16, chunkZ * 16, 16, 16);
ChunkPrimer primer = new ChunkPrimer();
setBlocksInChunk(primer);
caveGenerator.generate(worldObj, chunkX, chunkZ, primer);
if (CavelandConfig.generateRiver) {
ravineGenerator.generate(worldObj, chunkX, chunkZ, primer);
}
replaceBiomeBlocks(chunkX, chunkZ, primer);
Chunk chunk = new Chunk(worldObj, primer, chunkX, chunkZ);
byte[] biomeArray = chunk.getBiomeArray();
for (int i = 0; i < biomeArray.length; ++i) {
biomeArray[i] = (byte) Biome.getIdForBiome(biomesForGeneration[i]);
}
chunk.resetRelightChecks();
return chunk;
}
@Test(groups = "10s", timeOut = 60000)
public void test1() {
boolean bounded; // true if domains are bounded, false if they are enumerated
Random rand = new Random(0);
for (int k = 0; k < 20000; k++) {
long seed = System.currentTimeMillis();
rand.setSeed(seed);
bounded = rand.nextBoolean();
int size = 5; // domain size
int range = 15; // value range
int[][] domains;
if (bounded) {
domains = DomainBuilder.buildFullDomains(3, size, range, rand);
} else {
domains =
DomainBuilder.buildFullDomains2(
3, size, range, rand, rand.nextDouble(), rand.nextBoolean());
}
// total number of solutions: brut force algorithm
long base = brutForceTest(domains, bounded);
Model s = modeler(domains, bounded, seed);
// SearchMonitorFactory.log(s, false, false);
try {
while (s.getSolver().solve()) ;
} catch (AssertionError ae) {
System.err.printf("seed: %d\n", seed);
throw ae;
}
long cp = s.getSolver().getSolutionCount();
Assert.assertEquals(
cp, base, "found: " + cp + " solutions, while " + base + " are expected (" + seed + ")");
}
}
@Override
public boolean doReplanning(MobsimAgent withinDayAgent) {
random.setSeed(
Integer.parseInt(withinDayAgent.getId().toString()) * this.controler.getIterationNumber());
Plan executedPlan = WithinDayAgentUtils.getModifiablePlan(withinDayAgent);
// If we don't have an executed plan
if (executedPlan == null) return false;
PlanElement currentPlanElement = WithinDayAgentUtils.getCurrentPlanElement(withinDayAgent);
if (!(currentPlanElement instanceof Leg)) return false;
Leg currentLeg = (Leg) currentPlanElement;
int currentLinkIndex = WithinDayAgentUtils.getCurrentRouteLinkIdIndex(withinDayAgent);
// new Route for current Leg
this.microRouteCurrentLegRoute(
currentLeg,
executedPlan.getPerson(),
currentLinkIndex,
this.time,
scenario.getNetwork(),
tripRouter,
random,
executedPlan);
// Finally reset the cached Values of the PersonAgent - they may have changed!
WithinDayAgentUtils.resetCaches(withinDayAgent);
return true;
}
@Override
public void initialize(URL url, ResourceBundle resourceBundle) {
Random random = new Random();
random.setSeed(System.currentTimeMillis());
Singleton.INSTANCE.magicNumber = random.nextLong();
Singleton.INSTANCE.rightPairs = new ArrayList<String>();
Singleton.INSTANCE.balloons = FXCollections.observableArrayList();
Singleton.INSTANCE.pontosPlayer1 = 0;
Singleton.INSTANCE.pontosPlayer2 = 0;
this.imagesGridPane.setDisable(true);
this.messagesListView.setDisable(true);
this.messageInputField.setDisable(true);
this.enviarButton.setDisable(true);
for (Node node : this.imagesGridPane.getChildren()) {
node.getStyleClass().addAll("imageview", "imageview:hover");
}
this.messagesListView.setItems(Singleton.INSTANCE.balloons);
this.ipAddressLabel.setText(
String.format(
"Endereço IP: %s:%d",
Singleton.INSTANCE.localIPAddress, Singleton.INSTANCE.localIMServerPort));
}
@Before
public void setUp() throws Exception {
seed = System.currentTimeMillis();
rnd.setSeed(seed);
// rnd.setSeed(1308989334661L);
System.out.println(" > seed = " + seed);
}
/** RG-1: Tests if a all matchings are correct (on some random graphs). */
@Test
public void testRandomGraphs() {
Random rnd = new Random();
rnd.setSeed(54321);
for (int i = 1; i < 50; i++) {
int vertexCount = 2 + rnd.nextInt(i),
edgeCount = vertexCount + rnd.nextInt(vertexCount * (vertexCount - 1)) / 2,
subVertexCount = 1 + rnd.nextInt(vertexCount);
DirectedGraph<Integer, DefaultEdge>
g1 = SubgraphIsomorphismTestUtils.randomGraph(vertexCount, edgeCount, i),
g2 = SubgraphIsomorphismTestUtils.randomSubgraph(g1, subVertexCount, i);
VF2SubgraphIsomorphismInspector<Integer, DefaultEdge> vf2 =
new VF2SubgraphIsomorphismInspector<>(g1, g2);
SubgraphIsomorphismTestUtils.showLog(i + ": " + vertexCount + "v, " + edgeCount + "e ");
for (Iterator<GraphMapping<Integer, DefaultEdge>> mappings = vf2.getMappings();
mappings.hasNext(); ) {
assertEquals(true, SubgraphIsomorphismTestUtils.isCorrectMatching(mappings.next(), g1, g2));
SubgraphIsomorphismTestUtils.showLog(".");
}
SubgraphIsomorphismTestUtils.showLog("\n");
}
}
public TableModel produce(final DataRow parameters, final DataFactoryContext dataFactoryContext)
throws ReportDataFactoryException {
final int limit = getTypedParameter("limit", Integer.class, 100);
final long seed = getTypedParameter("seed", Long.class, System.currentTimeMillis());
final TypedTableModel model = new TypedTableModel();
model.addColumn("rowcount", Integer.class);
model.addColumn("integer", Integer.class);
model.addColumn("double", Double.class);
model.addColumn("text", String.class);
model.addColumn("text2", String.class);
model.addColumn("date", Date.class);
final Random random = new Random();
random.setSeed(seed);
final Calendar baseDate = new GregorianCalendar(2000, 1, 1);
baseDate.setTimeZone(TimeZone.getTimeZone("UTC"));
final long millis = baseDate.getTimeInMillis();
for (int i = 0; i < limit; i++) {
model.addRow(
i,
(int) (random.nextDouble() * Integer.MAX_VALUE) - (Integer.MAX_VALUE / 2),
random.nextDouble() * Integer.MAX_VALUE,
"Some Text with breaks " + i,
"SomeTextWithoutBreaks" + i,
new Date(millis + (long) (200 * random.nextDouble() * Integer.MAX_VALUE)));
}
return model;
}
public void ask(String channel, String sender, String login, String hostname, String message) {
Random random = new Random();
random.setSeed(message.hashCode());
List<String> list = new ArrayList<String>();
list.add("As I see it, yes");
list.add("It is certain");
list.add("It is decidedly so");
list.add("Most likely");
list.add("Outlook good");
list.add("Signs point to yes");
list.add("Without a doubt");
list.add("Yes");
list.add("Yes, definitely");
list.add("You may rely on it");
list.add("Don't count on it");
list.add("My reply is no");
list.add("My sources say no");
list.add("Outlook not so good");
list.add("Very doubtful");
list.add("Don't lose hope");
list.add("It may happen");
list.add("Maybe");
if (!(message.trim() == "")) {
Main.bot.sendMessage(channel, list.get(random.nextInt(list.size())));
}
}