void Low_tangent(edge *e_l, point *o_l, edge *e_r, point *o_r, edge **l_low, point **OL, edge **r_low, point **OR) {
for (point *d_l = Other(e_l, o_l), *d_r = Other(e_r, o_r); ; )
if (C3(o_l, o_r, d_l) < -eps) e_l = Prev(e_l, d_l), o_l = d_l, d_l = Other(e_l, o_l);
else if (C3(o_l, o_r, d_r) < -eps) e_r = Next(e_r, d_r), o_r = d_r, d_r = Other(e_r, o_r);
else break;
*OL = o_l, *OR = o_r; *l_low = e_l, *r_low = e_r;
}
void Merge(edge *lr, point *s, edge *rl, point *u, edge **tangent) {
double l1, l2, l3, l4, r1, r2, r3, r4, cot_L, cot_R, u1, v1, u2, v2, n1, cot_n, P1, cot_P;
point *O, *D, *OR, *OL; edge *B, *L, *R;
Low_tangent(lr, s, rl, u, &L, &OL, &R, &OR);
for (*tangent = B = Join(L, OL, R, OR, 0), O = OL, D = OR; ; ) {
edge *El = Next(B, O), *Er = Prev(B, D), *next, *prev;
point *l = Other(El, O), *r = Other(Er, D);
V(l, O, l1, l2); V(l, D, l3, l4); V(r, O, r1, r2); V(r, D, r3, r4);
double cl = C2(l1, l2, l3, l4), cr = C2(r1, r2, r3, r4);
bool BL = cl > eps, BR = cr > eps;
if (!BL && !BR) break;
if (BL) {
double dl = Dot(l1, l2, l3, l4);
for (cot_L = dl / cl; ; Remove(El), El = next, cot_L = cot_n) {
next = Next(El, O); V(Other(next, O), O, u1, v1); V(Other(next, O), D, u2, v2);
n1 = C2(u1, v1, u2, v2); if (!(n1 > eps)) break;
cot_n = Dot(u1, v1, u2, v2) / n1;
if (cot_n > cot_L) break;
}
} if (BR) {
double dr = Dot(r1, r2, r3, r4);
for (cot_R = dr / cr; ; Remove(Er), Er = prev, cot_R = cot_P) {
prev = Prev(Er, D); V(Other(prev, D), O, u1, v1); V(Other(prev, D), D, u2, v2);
P1 = C2(u1, v1, u2, v2); if (!(P1 > eps)) break;
cot_P = Dot(u1, v1, u2, v2) / P1;
if (cot_P > cot_R) break;
}
} l = Other(El, O); r = Other(Er, D);
if (!BL || (BL && BR && cot_R < cot_L)) B = Join(B, O, Er, r, 0), D = r;
else B = Join(El, l, B, D, 0), O = l;
}
}
void TabWidget::handleUploadRequested (const QString& str)
{
Pane *other = Other (static_cast<Pane*> (sender ()));
if (other->IsLocal ())
return;
Core::Instance ().Add (str, QUrl (other->GetString ()));
}
/* Play a game of tic-tac-toe */
void Game()
{
Square_Type Player;
char Answer[String_Length];
Board_Type Board;
int Move_Nbr = 1;
Initialize(Board);
Player = HUMANPIECE;
/*printf("\nDo you want to move first? ");
scanf_s("%s", Answer);
if (toupper(Answer[0]) == 'Y')
Player = 'O';
else
Player = 'X';
*/
while(Winner(Board) == ' ')
{
Print(Board);
Move(Board, Player, Move_Nbr);
Player = Other(Player);
Move_Nbr++;
}
Print(Board);
printf("Game over: ");
if (Winner(Board) != 'C')
printf("%s wins!\n", (Winner(Board) == COMPPIECE) ? "computer" : "human");
else
printf("draw!\n");
}
void aiEvents::generateEvent()
{
if (personA->dailyEvents[eventTime] == NULL)
{
eventType = ai_schedule1[eventTime];
if (eventType == EATING)
{
Eating* eating = &Eating(personA,aiList, eventTime);
eating->generateEating();
for (std::vector<aiPerson*>::iterator it = eating->aiInvolved.begin(); it != eating->aiInvolved.end(); it++)
{
eating->personA = (*it);
(*it)->dailyEvents[eventTime] = eating;
}
}
else if (eventType == WORKING)
{
Working* working = &Working(personA,aiList, eventTime);
working->generateWorking();
for (std::vector<aiPerson*>::iterator it = working->aiInvolved.begin(); it != working->aiInvolved.end(); it++)
{
working->personA = (*it);
(*it)->dailyEvents[eventTime] = working;
}
}
else if (eventType == RESTING)
{
Resting* resting = &Resting(personA,aiList, eventTime);
resting->generateResting();
for (std::vector<aiPerson*>::iterator it = resting->aiInvolved.begin(); it != resting->aiInvolved.end(); it++)
{
resting->personA = (*it);
(*it)->dailyEvents[eventTime] = resting;
}
}
else if (eventType == FIGHTING)
{
Fighting* fighting = &Fighting(personA,aiList, eventTime);
fighting->generateFighting();
for (std::vector<aiPerson*>::iterator it = fighting->aiInvolved.begin(); it != fighting->aiInvolved.end(); it++)
{
fighting->personA = (*it);
(*it)->dailyEvents[eventTime] = fighting;
}
}
else if (eventType == OTHER)
{
Other* other = &Other(personA,aiList, eventTime);
other->generateOther();
for (std::vector<aiPerson*>::iterator it = other->aiInvolved.begin(); it != other->aiInvolved.end(); it++)
{
other->personA = (*it);
(*it)->dailyEvents[eventTime] = other;
}
}
}
}
void Make_Graph() {
edge *start, *e; point *u, *v;
for (int i = 0; i < n; i++) {
start = e = (u = &p[i])->in;
do{ v = Other(e, u);
if (u < v) E[M++].u = (u - p, v - p, dis(u, v)); // M < aix * maxn
} while ((e = Next(e, u)) != start);
}
}
void FileFormatPrefs::OnFormatChoice(wxCommandEvent& evt)
{
int sel = mDefaultExportFormat->GetSelection();
int numSimpleFormats = sf_num_simple_formats();
if (sel == numSimpleFormats) {
Other();
}
else {
mFormat = sf_simple_format(sel)->format;
}
SetFormatText();
}
void GboxInstance::HandleMessage(const pp::Var& var_message) {
if (!var_message.is_string()) return;
std::string message = var_message.AsString();
pp::Var var_reply;
if (message == kHelloString) {
theLog.info("message: '%s'", message.c_str());
Hello();
} else if (message == kPaintMethodId) {
Paint();
} else if (message == kClockMethodId) {
Clock();
} else if (message == "quiet") {
theLog.info("message: '%s'", message.c_str());
Quiet();
} else {
theLog.info("other message: '%s'", message.c_str());
Other(message);
}
}
/* Return a heuristic used to determine the order in which the
children of a node are searched */
int Evaluate(Board_Type Board, Square_Type Player)
{
int I;
int Heuristic = 0;
for (I = 0; I < Possible_Wins; I++)
{
int J;
int Players = 0, Others = 0;
for (J = 0; J < 3; J++)
{
Square_Type Piece = Board[Three_in_a_Row[I][J]];
if (Piece == Player)
Players++;
else if (Piece == Other(Player))
Others++;
}
Heuristic += Heuristic_Array[Players][Others];
}
return Heuristic;
}
void aiEvents::updateEvent(int stages, aiPerson* person)
{
ai_event eventType = person->dailyEvents[stages]->eventType;
if (eventType != ai_schedule1[stages]) //reduece the aiInvolved by 1
{
for (std::vector<aiPerson*>::iterator it = person->dailyEvents[stages]->aiInvolved.begin(); it != person->dailyEvents[stages]->aiInvolved.end(); it++)
{
if ((*it) == person)
{
person->dailyEvents[stages]->aiInvolved.erase(it);
person->dailyEvents[stages]->possibility *= 0.75;
break;
}
}
if (eventType == WORKING) //generate new event for the ai
{
Working(person,aiList, (ai_time)stages).generateWorkingInterruptive();
}
else if (eventType == EATING)
{
Eating(person,aiList, (ai_time)stages).generateEatingInterruptive();
}
else if (eventType == RESTING)
{
Resting(person,aiList, (ai_time)stages).generateRestingInterruptive();
}
else if (eventType == FIGHTING)
{
Fighting(person,aiList, (ai_time)stages).generateFightingInterruptive();
}
else if (eventType == OTHER)
{
Other(person,aiList, (ai_time)stages).generateOtherInterruptive();
}
}
}
TreeNode* Parser::Statement()
{
kdDebug(0)<<"Parser::Statement()"<<endl;
while (currentToken.type == tokEOL) getToken(); // statements can allways start on newlines
switch (currentToken.type)
{
case tokLearn : return Learn(); break;
case tokIf : return If(); break;
case tokFor : return For(); break;
case tokForEach : return ForEach(); break;
case tokWhile : return While(); break;
case tokRun : return ExternalRun(); break;
case tokReturn : return Return(); break;
case tokBreak : return Break(); break;
case tokUnknown : return Other(); break; //assignment or function call
case tokClear : return Clear(); break;
case tokGo : return Go(); break;
case tokGoX : return GoX(); break;
case tokGoY : return GoY(); break;
case tokForward : return Forward(); break;
case tokBackward : return Backward(); break;
case tokDirection : return Direction(); break;
case tokTurnLeft : return TurnLeft(); break;
case tokTurnRight : return TurnRight(); break;
case tokCenter : return Center(); break;
case tokSetPenWidth : return SetPenWidth(); break;
case tokPenUp : return PenUp(); break;
case tokPenDown : return PenDown(); break;
case tokSetFgColor : return SetFgColor(); break;
case tokSetBgColor : return SetBgColor(); break;
case tokResizeCanvas : return ResizeCanvas(); break;
case tokSpriteShow : return SpriteShow(); break;
case tokSpriteHide : return SpriteHide(); break;
case tokSpritePress : return SpritePress(); break;
case tokSpriteChange : return SpriteChange(); break;
case tokPrint : return Print(); break;
case tokInputWindow : return InputWindow(); break;
case tokMessage : return Message(); break;
case tokFontType : return FontType(); break;
case tokFontSize : return FontSize(); break;
case tokRepeat : return Repeat(); break;
case tokRandom : return Random(); break;
case tokWait : return Wait(); break;
case tokWrapOn : return WrapOn(); break;
case tokWrapOff : return WrapOff(); break;
case tokReset : return Reset(); break;
case tokEOF : return EndOfFile(); break;
case tokEnd : Error(currentToken, i18n("Cannot understand ']'"), 1050);
getToken();
return new TreeNode(currentToken, Unknown);
break;
case tokBegin : Error(currentToken, i18n("Cannot understand '['"), 1050);
getToken();
return new TreeNode(currentToken, Unknown);
break;
default : break;
}
if (currentToken.type != tokEnd)
{
Error(currentToken, i18n("Cannot understand '%1'").arg(currentToken.look), 1060);
}
getToken();
return new TreeNode(currentToken, Unknown); // fall-though for unknowns
}
/* Return the score of the best move found for a board
The square to move to is returned in *Square */
int Best_Move(Board_Type Board, Square_Type Player, int *Square, int Move_Nbr, int Alpha, int Beta)
{
int Best_Square = -1;
int Moves = 0;
int I;
Move_Heuristic_Type Move_Heuristic[Squares];
Total_Nodes++;
/* Find the heuristic for each move and sort moves in descending order */
for (I = 0; I < Squares; I++)
{
if (Board[I] == Empty)
{
int Heuristic;
int J;
Play(Board, I, Player);
Heuristic = Evaluate(Board, Player);
Play(Board, I, Empty);
for (J = Moves-1; J >= 0 && Move_Heuristic[J].Heuristic < Heuristic; J--)
{
Move_Heuristic[J + 1].Heuristic = Move_Heuristic[J].Heuristic;
Move_Heuristic[J + 1].Square = Move_Heuristic[J].Square;
}
Move_Heuristic[J + 1].Heuristic = Heuristic;
Move_Heuristic[J + 1].Square = I;
Moves++;
}
}
for (I = 0; I < Moves; I++)
{
int Score;
int Sq = Move_Heuristic[I].Square;
Square_Type W;
/* Make a move and get its score */
Play(Board, Sq, Player);
W = Winner(Board);
if (W == 'X')
Score = (Maximum_Moves + 1) - Move_Nbr;
else if (W == 'O')
Score = Move_Nbr - (Maximum_Moves + 1);
else if (W == 'C')
Score = 0;
else
Score = Best_Move(Board, Other(Player), Square, Move_Nbr + 1, Alpha, Beta);
Play(Board, Sq, Empty);
/* Perform alpha-beta pruning */
if (Player == 'X')
{
if (Score >= Beta)
{
*Square = Sq;
return Score;
}
else if (Score > Alpha)
{
Alpha = Score;
Best_Square = Sq;
}
}
else
{
if (Score <= Alpha)
{
*Square = Sq;
return Score;
}
else if (Score < Beta)
{
Beta = Score;
Best_Square = Sq;
}
}
}
*Square = Best_Square;
if (Player == 'X')
return Alpha;
else
return Beta;
}
