Map::Map(SDL_Renderer* *gRender, LTexture2 *ver, LTexture2 *hor, Perso* J11, Perso *J12, Perso* J13, Perso* J14,int choix)
{
int x(0);
int y(0);
for (x = 0; x < 12; x++)
{
for (y = 0; y <12; y++)
{
bcarte[x][y] = new Bomb(0, 0);
carte[x][y] = new Wall(x, y, 0);
}
}
if (choix == 1){ Map1(); }
else{ Map2(); }
gRenderer = gRender;
vert = ver;
hori = hor;
J1 = J11;
J2 = J12;
J3 = J13;
J4 = J14;
}
int alternate_import_constructor_test(Epetra_Comm& Comm) {
int rv=0;
int nodes_per_proc=10;
int numprocs = Comm.NumProc();
int mypid = Comm.MyPID();
// Only run if we have multiple procs & MPI
if(numprocs==0) return 0;
#ifndef HAVE_MPI
return 0;
#endif
// Build Map 1 - linear
Epetra_Map Map1((long long)-1,nodes_per_proc,(long long)0,Comm);
// Build Map 2 - mod striped
std::vector<long long> MyGIDs(nodes_per_proc);
for(int i=0; i<nodes_per_proc; i++)
MyGIDs[i] = (mypid*nodes_per_proc + i) % numprocs;
Epetra_Map Map2((long long)-1,nodes_per_proc,&MyGIDs[0],(long long)0,Comm);
// For testing
Epetra_LongLongVector Source(Map1), Target(Map2);
// Build Import 1 - normal
Epetra_Import Import1(Map2,Map1);
rv = rv|| test_import_gid("Alt test: 2 map constructor",Source,Target, Import1);
// Build Import 2 - no-comm constructor
int Nremote=Import1.NumRemoteIDs();
const int * RemoteLIDs = Import1.RemoteLIDs();
std::vector<int> RemotePIDs(Nremote+1); // I hate you, stl vector....
std::vector<int> AllPIDs;
Epetra_Util::GetPids(Import1,AllPIDs,true);
for(int i=0; i<Nremote; i++) {
RemotePIDs[i]=AllPIDs[RemoteLIDs[i]];
}
Epetra_Import Import2(Import1.TargetMap(),Import1.SourceMap(),Nremote,&RemotePIDs[0],Import1.NumExportIDs(),Import1.ExportLIDs(),Import1.ExportPIDs());
rv = rv || test_import_gid("Alt test: no comm constructor",Source,Target,Import2);
// Build Import 3 - Remotes only
Epetra_Import Import3(Import1.TargetMap(),Import1.SourceMap(),Nremote,&RemotePIDs[0]);
rv = rv || test_import_gid("Alt test: remote only constructor",Source,Target, Import3);
return rv;
}
int main(int argc, char *argv[]) {
int ierr = 0, i;
#ifdef EPETRA_MPI
// Initialize MPI
MPI_Init(&argc,&argv);
int rank; // My process ID
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
Epetra_MpiComm Comm(MPI_COMM_WORLD);
#else
int rank = 0;
Epetra_SerialComm Comm;
#endif
#ifdef HAVE_EPETRA_TEUCHOS
Teuchos::RCP<Teuchos::FancyOStream>
fancyOut = Teuchos::VerboseObjectBase::getDefaultOStream();
if (Comm.NumProc() > 1 ) {
fancyOut->setShowProcRank(true);
fancyOut->setOutputToRootOnly(-1);
}
std::ostream &out = *fancyOut;
#else
std::ostream &out = std::cout;
#endif
Comm.SetTracebackMode(0); // This should shut down any error tracing
bool verbose = false;
// Check if we should print results to standard out
if (argc>1) if (argv[1][0]=='-' && argv[1][1]=='v') verbose = true;
// char tmp;
// if (rank==0) out << "Press any key to continue..."<< endl;
// if (rank==0) cin >> tmp;
// Comm.Barrier();
int MyPID = Comm.MyPID();
int NumProc = Comm.NumProc();
if (verbose && MyPID==0)
out << Epetra_Version() << endl << endl;
if (verbose) out << Comm <<endl;
bool verbose1 = verbose;
// Redefine verbose to only print on PE 0
if (verbose && rank!=0) verbose = false;
int NumMyElements = 10000;
int NumMyElements1 = NumMyElements; // Needed for localmap
int NumGlobalElements = NumMyElements*NumProc+EPETRA_MIN(NumProc,3);
if (MyPID < 3) NumMyElements++;
int IndexBase = 0;
int ElementSize = 7;
// Test LocalMap constructor
// and Petra-defined uniform linear distribution constructor
if (verbose) out << "\n*********************************************************" << endl;
if (verbose) out << "Checking Epetra_LocalMap(NumMyElements1, IndexBase, Comm)" << endl;
if (verbose) out << " and Epetra_BlockMap(NumGlobalElements, ElementSize, IndexBase, Comm)" << endl;
if (verbose) out << "*********************************************************" << endl;
Epetra_LocalMap *LocalMap = new Epetra_LocalMap(NumMyElements1, IndexBase,
Comm);
Epetra_BlockMap * BlockMap = new Epetra_BlockMap(NumGlobalElements, ElementSize, IndexBase, Comm);
EPETRA_TEST_ERR(VectorTests(*BlockMap, verbose),ierr);
EPETRA_TEST_ERR(MatrixTests(*BlockMap, *LocalMap, verbose),ierr);
delete BlockMap;
// Test User-defined linear distribution constructor
if (verbose) out << "\n*********************************************************" << endl;
if (verbose) out << "Checking Epetra_BlockMap(NumGlobalElements, NumMyElements, ElementSize, IndexBase, Comm)" << endl;
if (verbose) out << "*********************************************************" << endl;
BlockMap = new Epetra_BlockMap(NumGlobalElements, NumMyElements, ElementSize, IndexBase, Comm);
EPETRA_TEST_ERR(VectorTests(*BlockMap, verbose),ierr);
EPETRA_TEST_ERR(MatrixTests(*BlockMap, *LocalMap, verbose),ierr);
delete BlockMap;
// Test User-defined arbitrary distribution constructor
// Generate Global Element List. Do in reverse for fun!
int * MyGlobalElements = new int[NumMyElements];
int MaxMyGID = (Comm.MyPID()+1)*NumMyElements-1+IndexBase;
if (Comm.MyPID()>2) MaxMyGID+=3;
for (i = 0; i<NumMyElements; i++) MyGlobalElements[i] = MaxMyGID-i;
if (verbose) out << "\n*********************************************************" << endl;
if (verbose) out << "Checking Epetra_BlockMap(NumGlobalElements, NumMyElements, MyGlobalElements, ElementSize, IndexBase, Comm)" << endl;
if (verbose) out << "*********************************************************" << endl;
BlockMap = new Epetra_BlockMap(NumGlobalElements, NumMyElements, MyGlobalElements, ElementSize,
IndexBase, Comm);
EPETRA_TEST_ERR(VectorTests(*BlockMap, verbose),ierr);
EPETRA_TEST_ERR(MatrixTests(*BlockMap, *LocalMap, verbose),ierr);
delete BlockMap;
int * ElementSizeList = new int[NumMyElements];
int NumMyEquations = 0;
int NumGlobalEquations = 0;
for (i = 0; i<NumMyElements; i++)
{
ElementSizeList[i] = i%6+2; // blocksizes go from 2 to 7
NumMyEquations += ElementSizeList[i];
}
ElementSize = 7; // Set to maximum for use in checkmap
NumGlobalEquations = Comm.NumProc()*NumMyEquations;
// Adjust NumGlobalEquations based on processor ID
if (Comm.NumProc() > 3)
{
if (Comm.MyPID()>2)
NumGlobalEquations += 3*((NumMyElements)%6+2);
else
NumGlobalEquations -= (Comm.NumProc()-3)*((NumMyElements-1)%6+2);
}
if (verbose) out << "\n*********************************************************" << endl;
if (verbose) out << "Checking Epetra_BlockMap(NumGlobalElements, NumMyElements, MyGlobalElements, ElementSizeList, IndexBase, Comm)" << endl;
if (verbose) out << "*********************************************************" << endl;
BlockMap = new Epetra_BlockMap(NumGlobalElements, NumMyElements, MyGlobalElements, ElementSizeList,
IndexBase, Comm);
EPETRA_TEST_ERR(VectorTests(*BlockMap, verbose),ierr);
EPETRA_TEST_ERR(MatrixTests(*BlockMap, *LocalMap, verbose),ierr);
// Test Copy constructor
if (verbose) out << "\n*********************************************************" << endl;
if (verbose) out << "Checking Epetra_BlockMap(*BlockMap)" << endl;
if (verbose) out << "*********************************************************" << endl;
Epetra_BlockMap * BlockMap1 = new Epetra_BlockMap(*BlockMap);
EPETRA_TEST_ERR(VectorTests(*BlockMap, verbose),ierr);
EPETRA_TEST_ERR(MatrixTests(*BlockMap, *LocalMap, verbose),ierr);
delete [] ElementSizeList;
delete [] MyGlobalElements;
delete BlockMap;
delete BlockMap1;
// Test Petra-defined uniform linear distribution constructor
if (verbose) out << "\n*********************************************************" << endl;
if (verbose) out << "Checking Epetra_Map(NumGlobalElements, IndexBase, Comm)" << endl;
if (verbose) out << "*********************************************************" << endl;
Epetra_Map * Map = new Epetra_Map(NumGlobalElements, IndexBase, Comm);
EPETRA_TEST_ERR(VectorTests(*Map, verbose),ierr);
EPETRA_TEST_ERR(MatrixTests(*Map, *LocalMap, verbose),ierr);
delete Map;
// Test User-defined linear distribution constructor
if (verbose) out << "\n*********************************************************" << endl;
if (verbose) out << "Checking Epetra_Map(NumGlobalElements, NumMyElements, IndexBase, Comm)" << endl;
if (verbose) out << "*********************************************************" << endl;
Map = new Epetra_Map(NumGlobalElements, NumMyElements, IndexBase, Comm);
EPETRA_TEST_ERR(VectorTests(*Map, verbose),ierr);
EPETRA_TEST_ERR(MatrixTests(*Map, *LocalMap, verbose),ierr);
delete Map;
// Test User-defined arbitrary distribution constructor
// Generate Global Element List. Do in reverse for fun!
MyGlobalElements = new int[NumMyElements];
MaxMyGID = (Comm.MyPID()+1)*NumMyElements-1+IndexBase;
if (Comm.MyPID()>2) MaxMyGID+=3;
for (i = 0; i<NumMyElements; i++) MyGlobalElements[i] = MaxMyGID-i;
if (verbose) out << "\n*********************************************************" << endl;
if (verbose) out << "Checking Epetra_Map(NumGlobalElements, NumMyElements, MyGlobalElements, IndexBase, Comm)" << endl;
if (verbose) out << "*********************************************************" << endl;
Map = new Epetra_Map(NumGlobalElements, NumMyElements, MyGlobalElements,
IndexBase, Comm);
EPETRA_TEST_ERR(VectorTests(*Map, verbose),ierr);
EPETRA_TEST_ERR(MatrixTests(*Map, *LocalMap, verbose),ierr);
// Test Copy constructor
if (verbose) out << "\n*********************************************************" << endl;
if (verbose) out << "Checking Epetra_Map(*Map)" << endl;
if (verbose) out << "*********************************************************" << endl;
Epetra_Map Map1(*Map);
EPETRA_TEST_ERR(VectorTests(*Map, verbose),ierr);
EPETRA_TEST_ERR(MatrixTests(*Map, *LocalMap, verbose),ierr);
delete [] MyGlobalElements;
delete Map;
if (verbose1)
{
// Test Vector MFLOPS for 2D Dot Product
int M = 1;
int K = 1000000;
Epetra_Map Map2(-1, K, IndexBase, Comm);
Epetra_LocalMap Map3(M, IndexBase, Comm);
Epetra_Vector A(Map2);A.Random();
Epetra_Vector B(Map2);B.Random();
Epetra_Vector C(Map3);C.Random();
// Test Epetra_Vector label
const char* VecLabel = A.Label();
const char* VecLabel1 = "Epetra::Vector";
if (verbose) out << endl << endl <<"This should say " << VecLabel1 << ": " << VecLabel << endl << endl << endl;
EPETRA_TEST_ERR(strcmp(VecLabel1,VecLabel),ierr);
if (verbose) out << "Testing Assignment operator" << endl;
double tmp1 = 1.00001* (double) (MyPID+1);
double tmp2 = tmp1;
A[1] = tmp1;
tmp2 = A[1];
out << "On PE "<< MyPID << " A[1] should equal = " << tmp1;
if (tmp1==tmp2) out << " and it does!" << endl;
else out << " but it equals " << tmp2;
Comm.Barrier();
if (verbose) out << endl << endl << "Testing MFLOPs" << endl;
Epetra_Flops counter;
C.SetFlopCounter(counter);
Epetra_Time mytimer(Comm);
C.Multiply('T', 'N', 0.5, A, B, 0.0);
double Multiply_time = mytimer.ElapsedTime();
double Multiply_flops = C.Flops();
if (verbose) out << "\n\nTotal FLOPs = " << Multiply_flops << endl;
if (verbose) out << "Total Time = " << Multiply_time << endl;
if (verbose) out << "MFLOPs = " << Multiply_flops/Multiply_time/1000000.0 << endl;
Comm.Barrier();
// Test Vector ostream operator with Petra-defined uniform linear distribution constructor
// and a small vector
Epetra_Map Map4(100, IndexBase, Comm);
double * Dp = new double[100];
for (i=0; i<100; i++)
Dp[i] = i;
Epetra_Vector D(View, Map4,Dp);
if (verbose) out << "\n\nTesting ostream operator: Multivector should be 100-by-2 and print i,j indices"
<< endl << endl;
out << D << endl;
if (verbose) out << "Traceback Mode value = " << D.GetTracebackMode() << endl;
delete [] Dp;
}
#ifdef EPETRA_MPI
MPI_Finalize();
#endif
return ierr;
}
bool Aircraft::Step(float FT, sf::Vector2f Wind)
{
bool Die = false;
Time += FT;
const sf::Vector2f &Me = Shape.getPosition();
TakeoffSound.setPosition(Me.x, Me.y, 0.f);
FlySound.setPosition(Me.x, Me.y, 0.f);
LandingSound.setPosition(Me.x, Me.y, 0.f);
Shape.update(FT);
float Turning = 0.f;
switch (State)
{
case FlyingIn:
{
sf::Vector2f To(400.f, 300.f);
Shape.setRotation(Angle(Me - To));
if (P.NumPoints() > 0)
{
State = FlyingPath;
}
else if (Me.x > 100 && Me.x < 700 && Me.y > 100 && Me.y < 500)
{
State = FlyingFree;
Turning = 0.2f;
}
break;
}
case FlyingOut:
{
sf::Vector2f From(400.f, 300.f);
Shape.rotate(AngleDiff(Shape.getRotation(), Angle(From - Me)) * FT);
float Scale = Map(Speed / Template.Speed, 0.f, 1.f, 1.f, 0.9f);
float ShadowRadius = Radius * Scale;
sf::Vector2f Shadow = sf::Transform().scale(sf::Vector2f(Scale, Scale), sf::Vector2f(800 / 2, 600 * 0.8f)).transformPoint(Me);
if ((Me.x < -Radius || Me.x > (800 + Radius) || Me.y < -Radius || Me.y > (600 + Radius)) &&
(Shadow.x < -ShadowRadius || Shadow.x > (800 + ShadowRadius) || Shadow.y < -ShadowRadius || Shadow.y > (600 + ShadowRadius)))
{
Die = true;
}
break;
}
case FlyingFree:
{
float Angle = AngleFix(Shape.getRotation()), AddAngle;
if ((Me.x < 100 && Angle > 180) ||
(Me.x > 700 && Angle < 180) ||
(Me.y < 100 && (Angle > 90 && Angle < 270)) ||
(Me.y > 500 && (Angle > 270 || Angle < 90)))
{
AddAngle = Turn;
Turning = Turn / 10;
}
else if ((Me.x < 100 && Angle <= 180) ||
(Me.x > 700 && Angle >= 180) ||
(Me.y < 100 && (Angle <= 90 || Angle >= 270)) ||
(Me.y > 500 && (Angle <= 270 && Angle >= 90)))
{
AddAngle = -Turn;
Turning = -Turn / 10;
}
else
{
AddAngle = Turning;
}
Angle += AddAngle;
Shape.setRotation(AngleFix(Angle));
if (P.NumPoints() > 0)
{
State = FlyingPath;
}
break;
}
case FlyingPath:
{
if (P.NumPoints() > 0)
{
const sf::Vector2f To = P[0]; // might crash
if (InRange(Me, To, 5))
P.RemovePoint(0);
float Target = Angle(Me - To);
Shape.setRotation(Target);
if (Land &&
P.NumPoints() == 0 &&
/*Land->OnMe(Me) &&*/
P.Highlight
/*abs(AngleDiff(GetAngle(), Land->GetAngle())) <= Land->GetTemplate().LandAngle*/)
{
FlySound.stop();
LandingSound.play();
State = Landing;
LandPoint = Me;
}
else if (P.NumPoints() == 0)
{
if (Direction == Out &&
((OutDirection == OutUp && To.y < 50) ||
(OutDirection == OutDown && To.y > 550) ||
(OutDirection == OutLeft && To.x < 50) ||
(OutDirection == OutRight && To.x > 750)))
{
State = FlyingOut;
}
else
{
State = FlyingFree;
}
}
}
break;
}
case Landing:
{
sf::Vector2f Runway = Land->GetPos() + PolarToRect(sf::Vector2f(Land->GetLength() * 1.5f, Land->GetAngle()));
float Dist = Distance(Me, LandPoint);
Speed = Map(Dist, 0.f, Land->GetLength() * 1.1f, Template.Speed, 0.f);
if (Land->GetTemplate().Directional)
{
Shape.rotate(AngleDiff(Shape.getRotation(), Angle(Me - Runway)) * 3 * FT);
}
float Scale = Map2(Dist, 0.f, Land->GetLength() * 1.1f, 1.f, 0.65f);
Shape.setScale(Scale, Scale);
Radius = Template.Radius * Scale;
if (Dist > Land->GetLength())
{
Die = true;
}
break;
}
case TakingOff:
{
sf::Vector2f Runway = Land->GetPos() + PolarToRect(sf::Vector2f(Land->GetLength() * 1.5f, Land->GetAngle()));
float Dist = Distance(Me, Land->GetPos());
Speed = Map(Dist, 0.f, Land->GetLength() * 1.1f, 10.f, Template.Speed);
if (Land->GetTemplate().Directional)
{
Shape.rotate(AngleDiff(Shape.getRotation(), Angle(Me - Runway)) * 3 * FT);
}
float Scale = Map2(Dist, 0.f, Land->GetLength() * 1.1f, 0.65f, 1.f);
Shape.setScale(Scale, Scale);
Radius = Template.Radius * Scale;
if (Dist > Land->GetLength())
{
FlySound.play();
State = FlyingFree;
Land = 0;
}
break;
}
}
Shape.move(PolarToRect(sf::Vector2f(Speed, Shape.getRotation())) * FT);
Shape.move(Wind * FT * Magnitude(Shape.getScale()) / sqrt(2.f));
return Die;
}
void AD_FFDModifier::Map(AD_Vect3D *pos, AD_Vect3D *out)
{
AD_Vect3D q, pp, v;
float kw;
if (dim1==3)
{
Map3(pos, out);
return;
}
else
if (dim1==2)
{
Map2(pos, out);
return;
}
// Map4 inizia
mat_mulvect(&tm, pos, &pp);
if (invol)
{
if (pp.x<-EPSILON || pp.x>1.0f+EPSILON)
{
vect_copy(pos, out);
return;
}
if (pp.y<-EPSILON || pp.y>1.0f+EPSILON)
{
vect_copy(pos, out);
return;
}
if (pp.z<-EPSILON || pp.z>1.0f+EPSILON)
{
vect_copy(pos, out);
return;
}
}
q.x=q.y=q.z=0;
// Compute the deformed point as a weighted average of all
// 64 control points.
for (int i=0; i<dim1; i++)
{
for (int j=0; j<dim2; j++)
{
for (int k=0; k<dim3; k++)
{
v=cpoints[GRIDINDEX44(i,j,k)];
kw=BPoly4(i, pp.x)*BPoly4(j, pp.z)*BPoly4(k, pp.y);
v.x=v.x*kw;
v.y=v.y*kw;
v.z=v.z*kw;
vect_add_inline(&q, &v, &q);
}
}
}
mat_mulvect(&invtm, &q, out);
return;
}
