void
RandomKnot::assignColors(void)
{
// Initialize the color indices; -1 indicates an as-yet-unknown color.
int color = mPrefs.technicolor() ? -1 : 0;
for (int y = 0; y < mVSections; ++y) {
for (int x = 0; x < mHSections; ++x) {
mpSectionColors[BOT][y * mHSections + x] = color;
mpSectionColors[TOP][y * mHSections + x] = color;
}
}
++color;
// Assign colors to the sections by tracing all the 'strands' in the knot.
for (int y = 0; y < mVSections; ++y) {
for (int x = 0; x < mHSections; ++x) {
if (mpSectionColors[TOP][y * mHSections + x] < 0) {
// Assign a color to the top strand.
if (traceColor(color, TOP, x, y, 0, 0)) {
++color;
}
}
if (mpSectionColors[BOT][y * mHSections + x] < 0) {
// Assign a color to the bottom strand.
switch (mpSectionTypes[y * mHSections + x]) {
case D:
case H:
if (traceColor(color, BOT, x, y, 0, 1)) {
++color;
}
break;
case V:
if (traceColor(color, BOT, x, y, 1, 0)) {
++color;
}
break;
case N:
break;
}
}
}
}
// Generate the random colors.
mpColors = new RandomColor[color];
int hue = randomInteger(360);
const int gamut = 90 + randomInteger(270);
const int shift = gamut / color;
for (int i = 0; i < color; ++i) {
mpColors[i] = RandomColor(0.4, 0.9, 0.6, 1.0, 1.0, 1.0, hue);
hue = (hue + shift) % 360;
}
}
std::string itsAllGreek(std::ifstream &inFile) {
std::string greek;
char ch;
while (inFile.get(ch)) {
if (isupper(ch)) {
int rand = randomInteger('A', 'Z');
greek += rand;
} else if (islower(ch)) {
int rand = randomInteger('a', 'z');
greek += rand;
} else greek += ch;
}
return greek;
}
static bool hugeRangeSeemsReasonable() {
unsigned maskHigh;
int i, k, rangeBit, rangesLeft;
maskHigh = ((unsigned) INT_MAX + 1) >> 1;
rangesLeft = 0xF;
for (i = 0; i < N_TRIALS && rangesLeft; i++) {
k = randomInteger(INT_MIN, INT_MAX);
if (k < 0) {
rangeBit = (k & maskHigh) ? 1 : 2;
} else {
rangeBit = (k & maskHigh) ? 8 : 4;
}
rangesLeft &= ~rangeBit;
}
if (rangesLeft & 1) {
reportError("No large negative values generated");
}
if (rangesLeft & 2) {
reportError("No small negative values generated");
}
if (rangesLeft & 4) {
reportError("No small positive values generated");
}
if (rangesLeft & 8) {
reportError("No large positive values generated");
}
return rangesLeft == 0;
}
static bool randomIntegerSeemsReasonable(int low, int high) {
int i, k, rangeSize, *counts, outcome;
bool ok;
double expected;
rangeSize = high - low + 1;
counts = newArray(rangeSize, int);
for (i = 0; i < rangeSize; i++) {
counts[i] = 0;
}
ok = true;
for (i = 0; ok && i < N_TRIALS; i++) {
k = randomInteger(low, high);
if (k < low || k > high) {
reportError("randomInteger returned out of range value %d", k);
ok = false;
} else {
counts[k - low]++;
}
}
expected = (double) N_TRIALS / rangeSize;
for (i = 0; ok && i < rangeSize; i++) {
outcome = low + i;
if (counts[i] < 0.5 * expected) {
reportError("Low count for outcome %d", outcome);
ok = false;
} else if (counts[i] > 1.5 * expected) {
reportError("High count for outcome %d", outcome);
ok = false;
}
}
freeBlock(counts);
return ok;
}
void randomPermutation (int n, int *p)
{
for (int i = 0; i < n; ++i)
p[i] = i;
for (int i = 0; i < n - 1; ++i) {
int j = randomInteger(i, n - 1), ti = p[i];
p[i] = p[j];
p[j] = ti;
}
}
void batalha(Jogador eu, Jogador foe)
{
/* Toca a música especificada indefinidamente */
tocaMusica("bgm/ffvi.wav");
while (eu.status.hp > 0 && foe.status.hp > 0) {
/* Exibe barras de vida na tela */
lifebar(eu);
lifebar(foe);
/* Loop até chegar a vez de um personagem. O (+1) nesses dois
casos impede o personagem de nunca jogar caso SPD == 0. */
while (eu.atb < MAX_ATB && foe.atb < MAX_ATB) {
eu.atb += eu.status.spd + 1;
foe.atb += foe.status.spd + 1;
}
if (eu.atb >= MAX_ATB) {
eu.atb -= MAX_ATB;
do {
printf("\nSua vez! Digite 1 para atacar,\n"
"2 para carregar o golpe ou 3 para defender: ");
scanf("%d", &eu.acao);
if (eu.acao == 2 && eu.potencia == MAX_POW) {
puts("\n>Limite atingido! Impossível carregar mais.");
eu.acao = 0;
}
} while (eu.acao < 1 || eu.acao > 3);
turno(&eu, &foe);
}
else { /* (foe.atb >= MAX_ATB) */
congela(1);
foe.atb -= MAX_ATB;
do foe.acao = randomInteger(1, 3);
while (foe.potencia == MAX_POW && foe.acao == 2);
turno(&foe, &eu);
}
}
/* Encerra a execução da música */
paraMusica();
/* Exibe resultado da batalha */
lifebar(eu);
lifebar(foe);
printf("\n> %s foi aniquilado.\n",
(eu.status.hp <= 0) ? eu.nome : foe.nome);
printf("\n***** Você %s! *****\n\n",
(eu.status.hp > 0) ? "ganhou" : "perdeu");
}
bool acerto(int agiX, int agiY)
{
if (agiX >= 2*agiY) return true;
int chance = (agiX <= agiY) ? sin((double) agiX/agiY * PI_2) * 80
: cos((double) agiX/agiY * PI_2) * (-20) + 80;
#ifdef DEBUG
printf(" (Chance: %d%%)", chance);
#endif
return (randomInteger(1, 100) <= chance);
}
void drawTree(double x, double y, double r, double theta, int depth) {
if (depth < MAX_DEPTH) {
double growth = randomReal(0.1, 0.4);
setColor(TREE_COLORS[depth]);
GPoint branchPt = drawPolarLine(x, y, r * growth, theta);
int numChildren = randomInteger(2, 8);
for (int i = 0; i < numChildren; i++) {
double thetaPrime = theta + randomReal(-45, +45);
drawTree(branchPt.getX(), branchPt.getY(), (1.0 - growth) * r, thetaPrime, depth + 1);
}
}
}
RandomKnot::RandomKnot(const KnotStyle &knotStyle,
int windowWidth, int windowHeight, int maxSections)
: mWindowWidth(windowWidth),
mWindowHeight(windowHeight),
mHSections(3 + randomInteger(maxSections - 3)),
mVSections(3 + randomInteger(maxSections - 3)),
mOutlineStrokes(knotStyle.outline()),
mFillStrokes(knotStyle.fill()),
mHollow(randomFloat() < mPrefs.hollowKnotProbability()),
mpSectionTypes(0),
mpSectionCorners(0),
mpColors(0),
mDisplayList(0)
{
// Initialize the knot data. Derived classes have to establish
// the proper boundary conditions.
mpSectionTypes =
randomDirectionArray(mHSections, mVSections,
mPrefs.sectionProbability1(),
mPrefs.sectionProbability2());
mpSectionCorners =
randomDirectionArray(mHSections + 1, mVSections + 1,
mPrefs.cornerProbability1(),
mPrefs.cornerProbability2());
mpSectionColors[BOT] = new int[mHSections * mVSections];
mpSectionColors[TOP] = new int[mHSections * mVSections];
if (randomFloat() < mPrefs.symmetricKnotProbability()) {
// Enforce symmetries.
enforceHorizontalSymmetry(
randomFloat() < mPrefs.horizontalMirrorProbability());
enforceVerticalSymmetry(
randomFloat() < mPrefs.verticalMirrorProbability());
}
}
void ComsManage(void *vParameters)
{
coms *myComs=(coms*)vParameters;
char temp;
while(1)
{
// //send();
// // receive message per major cycle, frequency 5/100
if (globalCounter%1000==0&&randomInteger(0, 1000)<3) // 750
{
*(myComs->thrusterCommand)=receive();
switch(receive()%6){
case 0:
temp='F';
break;
case 1:
temp='B';
break;
case 2:
temp='L';
break;
case 3:
temp='R';
break;
case 4:
temp='D';
break;
default:
temp='H';
break;
}
if(*(myComs->response)!=temp){
resVar=!resVar;
*(myComs->response)=temp;
}
}
vTaskDelay(1000);
}
}
void reset() {
_x = (SCREEN_WIDTH / 2) - (BALL_SIZE / 2);
_y = (SCREEN_HEIGHT / 2) - (BALL_SIZE / 2);
int direction = randomInteger(1, 7);
switch (direction) {
case 1:
// Up/right
_xSpeed = MAX_BALL_SPEED;
_ySpeed = -MAX_BALL_SPEED;
break;
case 2:
// Right
_xSpeed = MAX_BALL_SPEED;
_ySpeed = 0.0f;
break;
case 3:
// Down/right
_xSpeed = MAX_BALL_SPEED;
_ySpeed = MAX_BALL_SPEED;
break;
case 4:
// Down/left
_xSpeed = -MAX_BALL_SPEED;
_ySpeed = MAX_BALL_SPEED;
break;
case 5:
// Left
_xSpeed = -MAX_BALL_SPEED;
_ySpeed = 0.0f;
break;
case 6:
// Up/left
_xSpeed = -MAX_BALL_SPEED;
_ySpeed = -MAX_BALL_SPEED;
break;
}
}
/*
* Function: RunSimulation
* Usage: RunSimulation();
* -----------------------
* This function runs the actual simulation. In each time unit,
* the program first checks to see whether a new customer arrives.
* Then, if the cashier is busy (indicated by a nonzero value for
* serviceTimeRemaining), the program decrements that variable to
* indicate that one more time unit has passed. Finally, if the
* cashier is free, the simulation serves another customer from
* the queue after recording the waiting time for that customer.
*/
void runSimulation() {
Queue<int> queue;
int serviceTimeRemaining = 0;
int nServed = 0;
long totalWait = 0;
long totalLength = 0;
for (int t = 0; t < SIMULATION_TIME; t++) {
if (randomChance(ARRIVAL_PROBABILITY)) {
queue.enqueue(t);
}
if (serviceTimeRemaining > 0) {
serviceTimeRemaining--;
if (serviceTimeRemaining == 0) nServed++;
} else if (!queue.isEmpty()) {
totalWait += t - queue.dequeue();
serviceTimeRemaining = randomInteger(MIN_SERVICE_TIME, MAX_SERVICE_TIME);
}
totalLength += queue.size();
}
reportResults(nServed, totalWait, totalLength);
}
unsigned int receive(){
return randomInteger(0, COMMAX);
}
void WorldMaze::createRandomMaze(WorldSize size) {
clearSelection(/* redraw */ false);
int rowsCols = getRowsCols(size) / 2 + 1;
worldGrid.resize(rowsCols, rowsCols);
worldGrid.fill(MAZE_FLOOR);
graph = gridToGraph(worldGrid);
// assign random weights to the edges
// give each edge a 'random' weight;
// put all edges into a priority queue, sorted by weight
Set<Edge*> edgeSet = graph->getEdgeSet();
int edgeCount = edgeSet.size();
for (Edge* edge : edgeSet) {
int weight = randomInteger(1, edgeCount * 1000);
edge->cost = weight;
}
// run the student's Kruskal algorithm to get a minimum spanning tree (MST)
Set<Edge*> mst = kruskal(*graph);
// convert the MST/graph back into a maze grid
// (insert a 'wall' between any neighbors that do not have a connecting edge)
graph->clearEdges();
for (Edge* edge : mst) {
graph->addEdge(edge->start, edge->finish);
graph->addEdge(edge->finish, edge->start);
}
// physical <-> logical size; a maze of size MxN has 2M-1 x 2N-1 grid cells.
// cells in row/col 0, 2, 4, ... are open squares (floors), and cells in
// row/col 1, 3, 5, ... are blocked (walls).
int digits = countDigits(rowsCols);
int worldSize = rowsCols * 2 - 1;
worldGrid.resize(worldSize, worldSize);
worldGrid.fill(MAZE_WALL);
pxPerWidth = (double) windowWidth / worldSize;
pxPerHeight = (double) windowHeight / worldSize;
for (int row = 0; row < worldSize; row++) {
for (int col = 0; col < worldSize; col++) {
if (row % 2 == 0 && col % 2 == 0) {
worldGrid.set(row, col, MAZE_FLOOR);
}
}
}
for (int row = 0; row < rowsCols; row++) {
int gridRow = row * 2;
for (int col = 0; col < rowsCols; col++) {
int gridCol = col * 2;
std::string name = vertexName(row, col, digits);
// decide whether to put open floor between neighbors
// (if there is an edge between them)
for (int dr = -1; dr <= 1; dr++) {
int nr = row + dr;
int gridNr = gridRow + dr;
for (int dc = -1; dc <= 1; dc++) {
int nc = col + dc;
int gridNc = gridCol + dc;
if ((nr != row && nc != col)
|| (nr == row && nc == col)
|| !worldGrid.inBounds(gridNr, gridNc)) {
continue;
}
std::string neighborName = vertexName(nr, nc, digits);
if (graph->containsEdge(name, neighborName)) {
worldGrid.set(gridNr, gridNc, MAZE_FLOOR);
}
}
}
}
}
delete graph;
graph = gridToGraph(worldGrid);
}
char randomChar(){
char alphabet[52] = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};
int randomNumber = randomInteger(0, 51);
char randomCharacter = alphabet[randomNumber];
return randomCharacter;
}
void turno(Jogador *x, Jogador *y)
{
int dano, i;
puts("\n----------------------------------------------------\n");
/* Desfaz os efeitos da defesa no turno anterior */
x->defendido = false;
switch (x->acao) {
/* Atacar */
case 1:
printf("> %s ataca", x->nome);
for (i = 0; i < 3; i++) {
printf(".");
fflush(stdout); /* evita que o buffer 'trave' */
congela(1);
}
if (acerto(x->status.agi, y->status.agi)) {
dano = x->status.atk - y->status.def;
if (y->defendido) dano -= y->status.def;
/* Evita dano 0 ou que 'cura' o oponente */
if (dano <= 0) dano = 1;
dano *= x->potencia;
dano += randomInteger((-dano)/5, dano/5);
if (critico(x->status.luck)) {
dano *= 2;
printf(" CRÍTICO!");
fflush(stdout);
congela(1);
}
y->status.hp -= dano;
if (y->status.hp < 0) y->status.hp = 0; /* HP nunca negativo */
printf("\nTira %d de vida.\n", dano);
}
else printf("\n%s se esquivou!\n", y->nome);
x->potencia = 1;
break;
/* Carregar */
case 2:
printf("> %s carrega energia.\nO dano agora é x%d!\n",
x->nome, ++(x->potencia));
break;
/* Defender */
case 3:
printf("> %s defende-se. DEF foi dobrada!\n", x->nome);
if (x->status.hp < x->status.maxHp) {
puts("Recupera 1 de vida!");
(x->status.hp)++;
}
x->defendido = true;
}
puts("\n----------------------------------------------------");
congela(1);
}
void
RandomKnot::prepareAnimation(Position extent, bool xRepeat, bool yRepeat)
{
// Find a random position within the window where the knot will be visible.
const GLfloat knotWidth = 2.0 * extent.x;
const GLfloat knotHeight = 2.0 * extent.y;
if (knotWidth < mWindowWidth && knotHeight < mWindowHeight) {
mBasePosition =
Position(randomFloat(mWindowWidth - knotWidth),
randomFloat(mWindowHeight - knotHeight))
+ extent;
} else {
mBasePosition = Position(randomFloat() * mWindowWidth,
randomFloat() * mWindowHeight);
}
// Give the knot a random speed, direction, angle and spin.
mSpeed = randomFloat(mPrefs.minSpeed(), mPrefs.maxSpeed()) + 0.1;
GLfloat dir;
if (randomFloat() < mPrefs.skewProbability()) {
dir = randomFloat(0.0, M_PI * 2.0);
if (xRepeat) {
mAngle = fmod(dir + M_PI_2, M_PI * 2.0);
} else if (yRepeat) {
mAngle = dir;
} else {
mAngle = randomFloat(0.0, M_PI * 2.0);
}
} else {
int quad;
if (xRepeat) {
quad = 2 * randomInteger(2) + 1;
} else if (yRepeat) {
quad = 2 * randomInteger(2);
} else {
quad = randomInteger(4);
}
dir = quad * M_PI_2;
mAngle = 0.0;
}
mDirection = Position(cos(dir), sin(dir));
if (randomFloat() < mPrefs.spinProbability()) {
mSpin = randomFloat(mPrefs.minSpin(), mPrefs.maxSpin())
* ((randomFloat() < 0.5) ? 1.0 : -1.0)
/ 180.0 * M_PI;
} else {
mSpin = 0.0;
}
// Calculate the starting and stopping times, i.e., the time at which
// the knot's bounding circle is tangent to the window's bounding circle.
//
// - project window midpoint to point P0 on line of movement at time T0.
// - use Pythagoras to compute distance from P0 to center of knot
// - calculate T0 - distance and T0 + distance
const Position midPosition(mWindowWidth * 0.5, mWindowHeight * 0.5);
const GLfloat t0 = (midPosition - mBasePosition) * mDirection;
const Position p0 = mBasePosition + t0 * mDirection;
const GLfloat hyp = norm(midPosition) + norm(extent);
const GLfloat cat = norm(midPosition - p0);
const GLfloat distance = sqrt(hyp * hyp - cat * cat);
mTime = t0 - distance;
mMaxTime = t0 + distance;
// Adjust the spin rate so the angle is consistent at start and stop.
GLfloat iterations = floor((mMaxTime - mTime) / mSpeed);
mSpin = floor(mSpin / M_PI * iterations) * M_PI / iterations;
}
bool critico(int sorte)
{
int chance = CRIT * (sorte + 10)/10.0;
return (randomInteger(1, 100) <= chance);
}
Grid<double> createRandomMaze(int size) {
Grid<double> maze(size, size, kMazeFloor);
BasicGraph* graph = gridToGraph(maze, mazeCost);
// assign random weights to the edges
// give each edge a 'random' weight;
// put all edges into a priority queue, sorted by weight
Set<Edge*> edgeSet = graph->getEdgeSet();
int edgeCount = edgeSet.size();
for (Edge* edge : edgeSet) {
int weight = randomInteger(1, edgeCount * 1000);
edge->cost = weight;
}
// run the student's Kruskal algorithm to get a minimum spanning tree (MST)
Set<Edge*> mst = kruskal(*graph);
// convert the MST/graph back into a maze grid
// (insert a 'wall' between any neighbors that do not have a connecting edge)
graph->clearEdges();
for (Edge* edge : mst) {
graph->addEdge(edge->start, edge->finish);
graph->addEdge(edge->finish, edge->start);
}
// physical <-> logical size; a maze of size MxN has 2M-1 x 2N-1 grid cells.
// cells in row/col 0, 2, 4, ... are open squares (floors), and cells in
// row/col 1, 3, 5, ... are blocked (walls).
int digits = countDigits(size);
int worldSize = size * 2 - 1;
Grid<double> world(worldSize, worldSize, kMazeWall);
for (int row = 0; row < worldSize; row++) {
for (int col = 0; col < worldSize; col++) {
if (row % 2 == 0 && col % 2 == 0) {
world[row][col] = kMazeFloor;
}
}
}
for (int row = 0; row < size; row++) {
int gridRow = row * 2;
for (int col = 0; col < size; col++) {
int gridCol = col * 2;
string name = vertexName(row, col, digits);
// decide whether to put open floor between neighbors
// (if there is an edge between them)
for (int dr = -1; dr <= 1; dr++) {
int nr = row + dr;
int gridNr = gridRow + dr;
for (int dc = -1; dc <= 1; dc++) {
int nc = col + dc;
int gridNc = gridCol + dc;
if ((nr != row && nc != col)
|| (nr == row && nc == col)
|| !world.inBounds(gridNr, gridNc)) {
continue;
}
string neighborName = vertexName(nr, nc, digits);
if (graph->containsEdge(name, neighborName)) {
world[gridNr][gridNc] = kMazeFloor;
}
}
}
}
}
delete graph;
return world;
}
