void getMatrix(int Row, int Col, int RowCount, int ColCount, int Matrix[MaxRows][MaxColumns])
{
drawEmptyMatrix(0,0, Row, Col, RowCount, ColCount );
//Zahlenabfrage
for(i=0; i < RowCount; i++)
{
for (j = 0; j < ColCount; j++)
{
BACKCOLOR_BLUE;
POSITION((Row+i),(Col+3 + (7*j)));
while(!scanf("%i", &Matrix[i][j]) || Matrix[i][j] <= -1000
|| Matrix[i][j] >= 10000 )
{
drawEmptyMatrix(i, j, Row, Col, RowCount, ColCount );
clearBuffer();
ATTRIBUTE_OFF;
POSITION((Row + i), Col+3+(7*j));
BACKCOLOR_BLUE;
}
POSITION((Row + i), Col + 2 +(7*j));
printf("%4i", Matrix[i][j]);
ATTRIBUTE_OFF;
}
}
}
// Eingabe-Abfrage
void getNumber(int Row, int Col, int *number)
{
POSITION (Row, Col);
while(!scanf("%i", number))
{
clearBuffer();
POSITION (Row, Col);
printf(" ");
POSITION (Row, Col);
}
}
void CInsertControlDlg::DoDataExchange(CDataExchange* pDX)
{
int iItem;
POSITION posControl;
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CInsertControlDlg)
DDX_Control(pDX, IDC_SERVERPATH, m_staticServerPath);
DDX_Control(pDX, IDC_REQUIREDCATEGORIES, m_butRequiredCategories);
DDX_Control(pDX, IDC_IGNOREREQUIREDCATEGORIES, m_butIgnoreRequiredCategories);
DDX_Control(pDX, IDOK, m_butOK);
DDX_Control(pDX, IDC_CONTROLS, m_lbControls);
//}}AFX_DATA_MAP
if( pDX->m_bSaveAndValidate )
{
iItem = m_lbControls.GetCurSel();
if( iItem == LB_ERR )
{
m_clsid = CLSID_NULL;
}
else
{
posControl = POSITION( m_lbControls.GetItemDataPtr( iItem ) );
ASSERT( posControl != NULL );
m_clsid = m_lControls.GetAt( posControl );
}
}
}
Image::Image(Entity *entity) : AComponent(entity, T_IMAGE, 0, 1)
{
POSITION(entity);
VISIBILITY(entity);
ROTATION(entity);
this->bitmap = NULL;
}
//leere Matrix zeichnen
void drawEmptyMatrix(int x, int y, int Row, int Col, int RowCount, int ColCount)
{
for(k=x; k < RowCount ; k++)
{
POSITION((Row+k),Col);
printf("|");
for (l=y; l < ColCount; l++)
{
POSITION((Row+k),(Col+1+(7*l)));
CLEAR_LINE;
BACKCOLOR_BLUE;
printf(" ---- ");
ATTRIBUTE_OFF;
}
printf("|");
}
}
char*
StringBitBoard(BitBoard bitBoard)
{
const int LINE_LENGTH = 36;
const int LINE_COUNT = 18;
// TODO: Reduce duplication from StringChessSet.
// Include space for newlines.
char ret[LINE_LENGTH * LINE_COUNT + 1 + 1000];
int file, offset, rank;
Position pos;
Side lineSide = Black;
char *topLine = " A B C D E F G H \n";
char *dottedLine = " ---------------------------------\n";
char *blackLine = " | |...| |...| |...| |...|\n";
char *whiteLine = " |...| |...| |...| |...| |\n";
// Add top lines.
strncpy(ret, topLine, LINE_LENGTH);
strncpy(ret+LINE_LENGTH, dottedLine, LINE_LENGTH);
for(rank = Rank8; rank >= Rank1; rank--) {
offset = 2*LINE_LENGTH + 2*LINE_LENGTH*(Rank8-rank);
// Add line.
strncpy(ret + offset, lineSide == White ? whiteLine : blackLine, LINE_LENGTH);
// Add number.
ret[offset] = '1'+rank;
// Add pieces.
// For the sake of debugging, avoid PieceAt() in case it is buggy.
offset += 4;
for(file = FileA; file <= FileH; file++) {
pos = POSITION(rank, file);
if((bitBoard&POSBOARD(pos)) == POSBOARD(pos)) {
ret[offset] = 'X';
}
offset += 4;
}
// Add dotted line.
strncpy(ret + offset, dottedLine, LINE_LENGTH);
lineSide = OPPOSITE(lineSide);
}
ret[LINE_LENGTH * LINE_COUNT] = '\0';
return strdup(ret);
}
//Text einlesen
void getText(unsigned char *text)
{
*text = 0;
do
{
POSITION(10, 1);
scanf("%150[^\n]", text);
clearBuffer();
}while (Strlen(text) == 0);
}
BoundingBox::BoundingBox(Entity *entity) :
AComponent(entity, T_BOUNDING_BOX),
width_(0),
height_(0),
collidable_(true),
marginX_(0),
marginY_(0)
{
POSITION(entity);
}
void getMatrix(int Row, int Col, int RowCount, int ColCount, int Matrix[MaxRows][MaxColumns])
{
int i,j,k;
for(i = 0; i < RowCount; i++)
{
POSITION( (Row+i),(Col));
CLEAR_LINE;
printf("| ");
for(j = 0; j < ColCount; j++)
{
printf("---- ");
}
printf("|\n");
}
for(i = 0; i < RowCount; i++)
{
for(j = 0; j < ColCount; j++)
{
POSITION( (Row + i),(Col + 2 + (5*j)) );
while( !(scanf("%i", &Matrix[i][j])) ) //Einlesen aktuelles Element
{ //Bei Falscheingabe:
POSITION( (Row + i),Col );
printf("| ");
for (k = 0; k < j; k++) //Neuschreiben der bisherigen Eingaben der Zeile
{
printf("%4i ", Matrix[i][k]);
}
for (k = k; k < ColCount; k++) //Neuschreiben der Platzhalter für einzuschreibende Elemente der Zeile
{
printf("---- ");
}
printf("|");
clearBuffer();
POSITION( (Row + i),(Col + 2 + (5 * j)) ); //Zurück an Position aktuell einzulesenden Elements springen
}
POSITION( (Row + i),(Col + 2 + (5 * j)) );
printf("%4i", Matrix[i][j]);
}
}
}
/*----------------------------------------------------------------*/
void input_analyze_data_range_load_next(input_data_t *uf)
{
Data_header *d;
char *c, field_name[3];
int i; /*, rvalue, index; */
signed short *spt;
Field_header *f;
Mandatory_header_block *m;
m = (Mandatory_header_block *)uf->data;
d = (Data_header *)(POSITION(uf->data, m->data_header));
c = (char *)d + sizeof(Data_header);
for (i=0; i<d->num_flds_rec; ++i, c+=4)
{
memcpy(field_name, c, 2);
field_name[2] = 0;
spt = (signed short *)(c + 2);
f = (Field_header *)(POSITION(uf->data, *spt));
add_to_fields(uf->data, m, f, field_name);
}
}
int getNumberOfColumns(int Row, int Col, int MatrixNo)
{
int number;
POSITION(Row, Col);
printf("Geben Sie bitte die Spaltenzahl der %i. Matrix ein (1...%i):____", MatrixNo, MaxRows);
getNumber(Row, 62, &number);
while( number < 1 || number > MaxColumns)
{
getNumber(Row, 62, &number);
}
return number;
}
int getNumberOfRows(int Row, int Col, int MatrixNo)
{
int number;
POSITION(Row,Col);
printf("Geben Sie bitte die Zeilenanzahl der %i. Matrix ein (1..%i): ", MatrixNo, MaxRows);
getNumber(Row, 62, &number);
while( (number < 1) || (number > MaxRows))
{
getNumber(Row, 62, &number);
}
return number;
}
int askAgain(int Row, int Col)
{
char W;
while(!scanf("%[jJnN]", &W))
{
POSITION(Row, Col);
CLEAR_LINE;
printf("Moechten Sie noch einmal (j/n) "); // Eingabeaufforderung
clearBuffer();
}
if (W == 'j' || W == 'J')
{
return 1;
}
return 0;
}
void printMatrix(int Row, int Col, int RowCount, int ColCount, int Matrix[MaxRows][MaxColumns])
{
int i,j;
for (i = 0; i < RowCount; i++)
{
POSITION( (Row+i),Col);
printf("| ");
for (j = 0; j < ColCount; j++)
{
printf("%4i ", Matrix[i][j]);
}
printf("|");
}
}
void Image::draw()
{
Position *position = POSITION(this->entity);
unsigned char opacity = VISIBILITY(this->entity)->opacity;
float angle = ROTATION(this->entity)->angle;
if (this->bitmap)
al_draw_tinted_rotated_bitmap(this->bitmap,
al_map_rgba(opacity, opacity, opacity, opacity),
angle == 0 ? 0 : al_get_bitmap_width(this->bitmap) / 2,
angle == 0 ? 0 : al_get_bitmap_height(this->bitmap) / 2,
angle == 0 ? position->x : position->x + al_get_bitmap_width(this->bitmap) / 2,
angle == 0 ? position->y : position->y + al_get_bitmap_height(this->bitmap) / 2,
angle,
0);
}
void printMatrix(int Row, int Col, int RowCount, int ColCount, int Matrix[MaxRows][MaxColumns])
{
drawEmptyMatrix(0,0, Row, Col, RowCount, ColCount);
for(i=0; i < RowCount; i++)
{
for (j = 0; j < ColCount; j++)
{
BACKCOLOR_BLUE;
POSITION((Row + i), Col + 2 +(7*j));
printf("%4i",Matrix[i][j]);
ATTRIBUTE_OFF;
}
}
}
void prData(Agnode_t * n, int pass)
{
char *pname;
char *bname;
char *tname;
char *name1;
char *name2;
int dist1, dist2;
if (PARENT(n))
pname = agnameof(PARENT(n));
else
pname = "<P0>";
if (BLOCK(n))
bname = agnameof(BLOCK(n)->sub_graph);
else
pname = "<B0>";
fprintf(stderr, "%s: %x %s %s ", agnameof(n), FLAGS(n), pname, bname);
switch (pass) {
case 0:
fprintf(stderr, "%d %d\n", VAL(n), LOWVAL(n));
break;
case 1:
if (TPARENT(n))
tname = agnameof(TPARENT(n));
else
tname = "<ROOT>";
dist1 = DISTONE(n);
if (dist1 > 0)
name1 = agnameof(LEAFONE(n));
else
name1 = "<null>";
dist2 = DISTTWO(n);
if (dist2 > 0)
name2 = agnameof(LEAFTWO(n));
else
name2 = "<null>";
fprintf(stderr, "%s %s %d %s %d\n", tname, name1, dist1, name2,
dist2);
break;
default:
fprintf(stderr, "%d\n", POSITION(n));
break;
}
}
void CInsertControlDlg::OnControlsSelChange()
{
int iItem;
POSITION posControl;
CString strServerPath;
CLSID clsid;
CDC dc;
CFont* pFont;
LPTSTR pszServerPath;
CRect rect;
CFont* pOldFont;
iItem = m_lbControls.GetCurSel();
if( iItem != LB_ERR )
{
m_butOK.EnableWindow( TRUE );
posControl = POSITION( m_lbControls.GetItemDataPtr( iItem ) );
clsid = m_lControls.GetAt( posControl );
GetClassServerPath( clsid, strServerPath );
dc.CreateCompatibleDC( NULL );
pFont = m_staticServerPath.GetFont();
pOldFont = dc.SelectObject( pFont );
// Workaround for SHLWAPI bug (in weird cases, PathCompactPath actually
// expands the pathname)
pszServerPath = strServerPath.GetBuffer( MAX_PATH+2 );
m_staticServerPath.GetWindowRect( &rect );
PathCompactPath( dc, pszServerPath, rect.Width() );
strServerPath.ReleaseBuffer();
dc.SelectObject( pOldFont );
m_staticServerPath.SetWindowText( strServerPath );
}
else
{
m_butOK.EnableWindow( FALSE );
m_staticServerPath.SetWindowText( NULL );
}
}
/*----------------------------------------------------------------*/
static void add_to_fields(char *uf,
Mandatory_header_block *m,
Field_header *f, char *name)
{
data_range_t *d;
signed short *spt; /* pointer to short */
int i; /*, j, j0, j1;*/
double value;
d = find_field(name);
if (d == NULL)
d = add_field(name);
spt = (signed short *)(POSITION(uf, f->position));
for (i=0; i<f->num_samples; ++i, ++spt)
{
if (*spt == m->missing)
continue;
value = (double)(*spt)/(double)(f->scale_factor);
add_to_field(d, value);
}
return;
}
int BoundingBox::getCenterX() const
{
return (this->width_ / 2) + this->marginX_ + POSITION(this->entity)->x;
}
int BoundingBox::getYY() const
{
return POSITION(this->entity)->y + this->marginY_ + this->height_;
}
int BoundingBox::getXX() const
{
return POSITION(this->entity)->x + this->marginX_ + this->width_;
}
// ASCII-art representation of chessboard.
char*
StringChessSet(ChessSet *chessSet)
{
const int LINE_LENGTH = 36;
const int LINE_COUNT = 18;
// Include space for newlines.
char ret[LINE_LENGTH * LINE_COUNT + 1 + 1000];
char pieceChr;
int file, offset, rank;
Piece piece;
Position pos;
Side side;
Side lineSide = Black;
char *topLine = " A B C D E F G H \n";
char *dottedLine = " ---------------------------------\n";
char *blackLine = " | |...| |...| |...| |...|\n";
char *whiteLine = " |...| |...| |...| |...| |\n";
// Add top lines.
strncpy(ret, topLine, LINE_LENGTH);
strncpy(ret+LINE_LENGTH, dottedLine, LINE_LENGTH);
// Outputs chess set as ascii-art.
// pieces are upper-case if white, lower-case if black.
// P=pawn, R=rook, N=knight, B=bishop, Q=queen, K=king, .=empty square.
// e.g., the initial position is output as follows:-
// A B C D E F G H
// ---------------------------------
// 8 | r |.n.| b |.q.| k |.b.| n |.r.|
// ---------------------------------
// 7 |.p.| p |.p.| p |.p.| p |.p.| p |
// ---------------------------------
// 6 | |...| |...| |...| |...|
// ---------------------------------
// 5 |...| |...| |...| |...| |
// ---------------------------------
// 4 | |...| |...| |...| |...|
// ---------------------------------
// 3 |...| |...| |...| |...| |
// ---------------------------------
// 2 | P |.P.| P |.P.| P |.P.| P |.P.|
// ---------------------------------
// 1 |.R.| N |.B.| Q |.K.| B |.N.| R |
// ---------------------------------
for(rank = Rank8; rank >= Rank1; rank--) {
offset = 2*LINE_LENGTH + 2*LINE_LENGTH*(Rank8-rank);
// Add line.
strncpy(ret + offset, lineSide == White ? whiteLine : blackLine, LINE_LENGTH);
// Add number.
ret[offset] = '1'+rank;
// Add pieces.
// For the sake of debugging, avoid PieceAt() in case it is buggy.
offset += 4;
for(file = FileA; file <= FileH; file++) {
pos = POSITION(rank, file);
pieceChr = '\0';
for(side = White; side <= Black; side++) {
for(piece = Pawn; piece <= King; piece++) {
if((chessSet->Sets[side].Boards[piece]&POSBOARD(pos)) == POSBOARD(pos)) {
switch(piece) {
case Pawn:
pieceChr = 'P';
break;
case Rook:
pieceChr = 'R';
break;
case Knight:
pieceChr = 'N';
break;
case Bishop:
pieceChr = 'B';
break;
case Queen:
pieceChr = 'Q';
break;
case King:
pieceChr = 'K';
break;
default:
panic("Impossible.");
}
goto loop;
}
}
}
loop:
if(pieceChr != '\0') {
if(side == Black) {
pieceChr += 32;
}
ret[offset] = pieceChr;
}
offset += 4;
}
// Add dotted line.
strncpy(ret + offset, dottedLine, LINE_LENGTH);
lineSide = OPPOSITE(lineSide);
}
ret[LINE_LENGTH * LINE_COUNT] = '\0';
return strdup(ret);
}
nodelist_t *layout_block(Agraph_t * g, block_t * sn, double min_dist)
{
Agnode_t *n;
Agraph_t *copyG, *tree, *subg;
nodelist_t *longest_path;
nodelistitem_t *item;
int N, k;
double theta, radius, largest_node;
largest_node = 0;
subg = sn->sub_graph;
block_graph(g, sn); /* add induced edges */
copyG = remove_pair_edges(subg);
tree = spanning_tree(copyG);
longest_path = find_longest_path(tree);
place_residual_nodes(subg, longest_path);
/* at this point, longest_path is a list of all nodes in the block */
/* apply crossing reduction algorithms here */
longest_path = reduce_edge_crossings(longest_path, subg);
N = sizeNodelist(longest_path);
largest_node = largest_nodesize(longest_path);
/* N*(min_dist+largest_node) is roughly circumference of required circle */
if (N == 1)
radius = 0;
else
radius = (N * (min_dist + largest_node)) / (2 * PI);
for (item = longest_path->first; item; item = item->next) {
n = item->curr;
if (ISPARENT(n)) {
/* QUESTION: Why is only one parent realigned? */
realignNodelist(longest_path, item);
break;
}
}
k = 0;
for (item = longest_path->first; item; item = item->next) {
n = item->curr;
POSITION(n) = k;
PSI(n) = 0.0;
theta = k * ((2.0 * PI) / N);
ND_pos(n)[0] = radius * cos(theta);
ND_pos(n)[1] = radius * sin(theta);
k++;
}
if (N == 1)
sn->radius = largest_node / 2;
else
sn->radius = radius;
sn->rad0 = sn->radius;
/* initialize parent pos */
sn->parent_pos = -1;
agclose(copyG);
return longest_path;
}
int main()
{
double Op1, Op2, Erg; //Operanden und Ergebnisvariabeln
int Menuewahl, GueltigeEingabe;
char Dummy;
do
{
//Menue anzeigen
CLEAR;
HOME;
printf("Einfacher Taschenrechner\n");
printf("========================\n");
POSITION(3, 4);
printf("1. Addition\n");
POSITION(4, 4);
printf("2. Subtraktion\n");
POSITION(5, 4);
printf("3. Multiplikation\n");
POSITION(6, 4);
printf("4. Division\n");
POSITION(7, 4);
printf("9. Programmende\n");
CLEAR_LINE;
POSITION(9, 1);
INVERSE;
printf("Ihre wahl: ");
ATTRIBUTE_OFF;
GueltigeEingabe = scanf("%i", &Menuewahl);
do
{
scanf("%c", &Dummy);
}while (Dummy != '\n');
//Wahl Rechenart oder Programmende
if (GueltigeEingabe) //if true
{
POSITION(11,1);
switch(Menuewahl)
{
case 1: printf("Addition\n");
printf("--------\n");
break;
case 2: printf("Subtraktion\n");
printf("-----------\n");
break;
case 3: printf("Multiplikation\n");
printf("--------------\n");
break;
case 4: printf("Division\n");
printf("--------\n");
break;
default: GueltigeEingabe = 0;
break;
}
if (GueltigeEingabe) //ausser bei Programmende
{
do
{
scanf("%c", &Dummy);
}while (Dummy != '\n');
//Operand 1 erfragen
do
{
POSITION(14, 1); //Eingabezeile loeschen
printf("Geben Sie bitte den ersten Operanden ein: ");
GueltigeEingabe = scanf("%lf", &Op1);
do
{
scanf("%c", &Dummy);
} while (Dummy != '\n');
if (GueltigeEingabe == 0)
{
POSITION(15, 1);
printf("falsche Eingabe!\n");
}
} while (!GueltigeEingabe);
//Operand 2 erfragen
do
{
POSITION(15, 1);
printf("Geben Sie bitte den zweiten Operanden ein: ");
GueltigeEingabe = scanf("%lf", &Op2);
do
{
scanf("%c", &Dummy);
} while (Dummy != '\n');
if (GueltigeEingabe == 0)
printf("falsche Eingabe\n");
else if (Menuewahl == 4 && Op2 == 0.0)
{
printf("Division durch 0");
GueltigeEingabe = 0;;
}
} while (!GueltigeEingabe);
}
//Werte ausgeben
POSITION(18,1);
switch(Menuewahl)
{
case 1: Erg = Op1 + Op2;
printf("%lf + %lf = %lf\n", Op1, Op2, Erg);
break;
case 2: Erg = Op1 - Op2;
printf("%lf - %lf = %lf\n", Op1, Op2, Erg);
break;
case 3: Erg = Op1 * Op2;
printf("%lf * %lf = %lf\n", Op1, Op2, Erg);
break;
case 4: Erg = Op1 / Op2;
printf("%lf / %lf = %lf\n", Op1, Op2, Erg);
break;
case 9: break;
default: printf("falsche Eingabe!\n");
break;
}
}
else
{
printf("falsche Eingabe!");
}
POSITION(20, 1);
INVERSE;
FORECOLOR_KOBALT;
printf("Bitte druecken Sie die Eingabetaste ...\n");
ATTRIBUTE_OFF;
do
{
scanf("%c",&Dummy);
} while (Dummy != '\n');
} while (Menuewahl != 9); // Programmaustieg
printf("ciao ciao\n");
return 0;
}
int BoundingBox::getCenterY() const
{
return (this->height_ / 2) + this->marginY_ + POSITION(this->entity)->y;
}
void clearScreen()
{
CLEAR;
POSITION(1, 1);
}
// aus dem Skript "Grundlagen der Informatik", Kap. 6.3
int main()
{
char Dummy; // für Tastaturpuffer-Löschen
int Menuewahl; // Benutzereingabe Menüauswahl
int Eingabe; // Ergebnis von scanf
double X; // Laufvariable
double X_Von, X_Bis; // Ausgabegrenzen
double X_Schrittweite; // Ausgabeschrittweite
do
{
// Menue ausgeben
CLEAR; // Bildschirm löschen
HOME;
printf("Sinus & Co.\n");
printf("===========\n\n");
printf("1. sin(x)\n");
printf("2. cos(x)\n");
printf("3. tan(x)\n");
printf("9. Programmende\n\n");
// Benutzereingabe Menue
do
{
POSITION(9, 1); // Eingabezeile löschen
CLEAR_LINE;
POSITION(9, 1);
printf("Ihre Wahl: ");
Eingabe = scanf("%i", &Menuewahl);
do // Tastaturpuffer loeschen
scanf("%c", &Dummy);
while (Dummy != '\n');
if (Eingabe) // wenn Zahl eingegeben
{ // dann pruefen, ob gueltig
POSITION(11, 1);
switch(Menuewahl)
{
case 1: printf("SINUS\n-----\n"); break;
case 2: printf("COSINUS\n-------\n"); break;
case 3: printf("TANGENS\n-------\n"); break;
case 9: printf("PROGRAMMENDE\n\n"); break;
default: Eingabe = 0;
}
}
} while (!Eingabe); // solange bis gültiger
// Menüpunkt gewählt wurde
if (Menuewahl != 9) // außer bei Programmende
{
// Startwert erfragen
do
{
POSITION(14, 1); // Eingabezeile löschen
CLEAR_LINE;
POSITION(14, 1);
printf("Von x = ");
Eingabe = scanf("%lf", &X_Von);
Seite
2
von
3
G. Kempfer, BHT Berlin, TI-B IN1, Übungsblatt 6
do // Tastaturpuffer loeschen
scanf("%c", &Dummy);
while (Dummy != '\n');
} while (!Eingabe); // solange bis gültige Eingabe
// Endwert erfragen
do
{
POSITION(15, 1); // Eingabezeile löschen
CLEAR_LINE;
POSITION(15, 1);
printf("Bis x = ");
Eingabe = scanf("%lf", &X_Bis);
do // Tastaturpuffer loeschen
scanf("%c", &Dummy);
while (Dummy != '\n');
if (Eingabe)
if (X_Von > X_Bis) // Ausgabegrenzen prüfen
Eingabe = 0;
} while (!Eingabe); // solange bis gültige Eingabe
// Schrittweite erfragen
do
{
POSITION(16, 1); // Eingabezeile löschen
CLEAR_LINE;
POSITION(16, 1);
printf("Schrittweite = ");
Eingabe = scanf("%lf", &X_Schrittweite);
do // Tastaturpuffer loeschen
scanf("%c", &Dummy);
while (Dummy != '\n');
} while (!Eingabe); // solange bis gültige Eingabe
// Werte ausgeben
POSITION(18, 1);
printf(" X | f(x)\n");
printf("---------|---------\n");
for (X = X_Von; X <= X_Bis; X += X_Schrittweite)
{
switch(Menuewahl)
{
case 1: printf("%f | %f\n", X, sin(X)); break;
case 2: printf("%f | %f\n", X, cos(X)); break;
case 3: printf("%f | %f\n", X, tan(X)); break;
}
}
// Eingabetaste abwarten
printf("\nBitte Eingabetaste druecken ...");
do
scanf("%c", &Dummy);
while (Dummy != '\n');
}
} while (Menuewahl != 9); // solange bis Programmende
return 0;
}
// this is run after all the clicking and decision to move are made
void CHUZZLE_BOARD::logic(CP_OBJECT_MANAGER<TILE> &manager)
{
std::list<counted_ptr<TILE> > nukable;
GRID_DATA temp = data;
int rotate_count = 0;
bool no_nukable = true;
if ((direction == N) || (direction == S))
{
for (int c = 0; c < data.height(); c++)
{
rotate_count = c;
temp.rotate(selection.x, direction);
//nukable =
int nukable_size = temp.find_nukable();
// nukable = temp.remove_nukable();
if (nukable_size > 0)
{
/*
// add all nuked to the manager
for (std::list<counted_ptr<TILE> >::iterator i = nukable.begin(); i != nukable.end(); i++)
{
// (*i)->ungrid();
manager.add(counted_ptr<TILE>(*i));
}
*/
no_nukable = false;
break;
}
}
if (!no_nukable)
{
rotate_count++;
for (int c = 0; c < rotate_count; c++)
{
data.rotate(selection.x, direction);
}
data.shove_line(selection.x, direction);
data.shove_all();
}
}
else if ((direction == E) ||(direction == W))
{
for (int c = 0; c < data.width(); c++)
{
rotate_count = c;
temp.rotate(selection.y, direction);
//nukable =
int nukable_size = temp.find_nukable();
// nukable = temp.remove_nukable();
if (nukable_size > 0)
{
/*
// add all nuked to the manager
for (std::list<counted_ptr<TILE> >::iterator i = nukable.begin(); i != nukable.end(); i++)
{
// (*i)->ungrid();
manager.add(counted_ptr<TILE>(*i));
}
*/
no_nukable = false;
break;
}
}
if (!no_nukable)
{
rotate_count++;
for (int c = 0; c < rotate_count; c++)
{
data.rotate(selection.y, direction);
}
data.shove_line(selection.y, direction);
data.shove_all();
}
}
if ((direction == N) || (direction == S))
{
for(int y = 0; y < data.height(); y++)
{
counted_ptr<TILE> &t = data.at(POSITION(selection.x, y));
if (no_nukable)
t->shove(t->pos, direction, false);
}
}
else if ((direction == E) ||(direction == W))
{
for(int x = 0; x < data.width(); x++)
{
counted_ptr<TILE> &t = data.at(POSITION(x, selection.y));
if (no_nukable)
t->shove(t->pos, direction, false);
}
}
}
