// compute turn and save to array
int iSaveTurn(int iX, int iY, int NumberOfRay)
{
double dXt; // = dX-dAlfaX = translation
double dYt; // = dY-dAlfaY
double turn;
// distance to alfa fixed point ( target set )
int iDistance;
double dDistance2; //
dXt = ( GiveZx(iX) - dAlfaX);
dYt = ( GiveZy(iY) - dAlfaY );
dDistance2 = dXt*dXt + dYt*dYt;
if (dMaxDistance2Alfa2>dDistance2)
{
turn = GiveTurn( dXt, dYt);
iDistance = (int)(sqrt(dDistance2)/PixelWidth);
// printf("Zx = %f; Zy= %f iDistance = %d\n",GiveZx(iX),GiveZx(iY), iDistance); // debug info
if (iDistance<=iMaxDistance2Alfa) RaysTurns[iDistance][NumberOfRay] = turn;
}
return 0;
}
/*
finds offset in turns of parabolic Julia set
Method is described here :
Complex Dynamics by Lennart Carleson,Theodore Williams Gamelin
page 40
------------Explanation and code by Wolf Jung ------------------------
> The problem is that for q = 10 it is computing 1025 coefficients
> where only 12 are needed. Try the following and compare the
> results with the existing program:
> * Allocate a matrix array a_mn with m <= q and n <= q+1.
> * Set a_11 = lambda , a_12 = 1 , and a_13 ... a_1,q+1 = 0.
> * For m = 1 to q-1 for n = 1 to q+1
> a_m+1,n = lambda*a_mn + sum a_mk * a_m,n-k
> where the summation is from k = 1 to n-1.
> Then a_mn is the coefficient of z^n in f^m , with
> f = lambda*z + z^2 . So the desired A is a_q,q+1 .
>
> In fact you only need one row instead of a quadratic array
> by redefining the variables:
> * Allocate an array a_n with n <= q+1.
> * Set a_1 = lambda , a_2 = 1 , and a_3 ... a_q+1 = 0.
> * For m = 1 to q-1 for n = q+1 down to 1 (not up !)
> a_n = lambda*a_n + sum a_k * a_n-k
> where the summation is from k = 1 to n-1.
>
> Or in c++:
> int k, m, n; complex a[q+2];
> a[1] = lambda; a[2] = complex(1.0);
> for (n = 3; n <= q+1; n++) a[n] = 0;
> for (m = 1; m < q; m++) for (n = q+1; n; n--)
> { a[n] *= lambda;
> for (k = 1; k < n; k++) a[n] += a[k]*a[n-k];
> }
> //Now a[q+1] = A with f^q(z) = z + a*z^(q+1) + ...
>
> Best regards,
>
> Wolf
*/
double GiveOffset(int p, int q )
{
double complex a[iPeriodChild+2];
double complex lambda;
double t; // = Internal Angle In radians
double offset;
int k, m, n; // index of for loops
double complex coeff;
t = ((double)p/q) *2*M_PI; // from turns to radians
lambda= (cos(t)+I*sin(t));
// a[0]=0;
a[1] = lambda;
a[2] = 1.0;
for (n = 3; n <= q+1; n++) a[n] = 0;
//
for (m = 1; m < q; m++)
for (n = q+1; n; n--)
{ a[n] *= lambda;
for (k = 1; k < n; k++)
a[n] += a[k]*a[n-k]; // sum
}
//Now a[q+1] = A with f^q(z) = z + a*z^(q+1) + ...
coeff = a[q+1];
offset= -GiveTurn(creal(coeff), cimag(coeff))/q;
return offset;
}
int GameManager::ChangeTurn(int finishedPlayerID)
{
//int nextTurnPlayerID;
if (finishedPlayerID == 1)
{
// GiveTurn(2);
// return 2;
}
if (finishedPlayerID==2)
{
GiveTurn(1);
return 1;
}
//return nextTurnPlayerID;
}
int ColourNewTrap(unsigned char A[])
{
unsigned int ix, iy; // pixel coordinate
double Zx, Zy; // Z= Zx+ZY*i;
double Zxt, Zyt;
unsigned i; /* index of 1D array */
double dDistance2; // = sqr( distance to alfa)
int iDistance;
double turn;
for(iy=iyMin;iy<=iyMax;++iy)
{
Zy = GiveZy(iy);
Zyt = Zy -dAlfaY;// translation near fixed point alfa
for(ix=ixMin;ix<=ixMax;++ix)
{
// from screen to world coordinate
Zx = GiveZx(ix);
// translation near fixed point alfa
Zxt = Zx - dAlfaX;
//
turn = GiveTurn(Zxt, Zyt);
dDistance2 = Zxt*Zxt + Zyt*Zyt ;
iDistance = (int)(sqrt(dDistance2)/PixelWidth);
// check if point z is inside triangle around arm of critical orbit
if ( dDistance2 < dMaxDistance2Alfa2 && turn>RaysTurns[iDistance][iPeriodChild-2] && turn<RaysTurns[iDistance][iPeriodChild-1])
{ i = Give_i(ix, iy); /* compute index of 1D array from indices of 2D array */
if ( A[i]==255) A[i]=0; // rays
else A[i]= 255-A[i]; // mark the trap
}
}
}
return 0;
}
void GameManager::SetTwoPlayer()
{
//하드코딩
m_PlayerList[1] = new Player(1, TEAM_A);
m_PlayerList[2] = new Player(2, TEAM_B);
m_Player1 = m_PlayerList[1];
m_Player2 = m_PlayerList[2];
auto objlayer = GET_OBJECT_LAYER;
auto firstP = m_PlayerList.find(1);
firstP->second->MakeTank(1, Vec2(500.0f, 100.0f));
objlayer->AddTank(firstP->second->GetTank());
auto secondP = m_PlayerList.find(2);
secondP->second->MakeTank(2, Vec2(100.0f, 100.0f));
objlayer->AddTank(secondP->second->GetTank());
m_WhoseTurn = firstP->second->GetPlayerID();
GiveTurn(m_WhoseTurn);
}
// compute turn and save to array
// ray goes : from inf thru z0 thru z1 to alfa
// it means that external radius of z0 is greater than external radius of z0
// it does not mean that iDistance0 iDistance1 ( because ray can turn )
double SaveTurns(double Zx0, double Zy0, double Zx1, double Zy1, int NumberOfRay)
{
double xt; // = x-dAlfaX = translation
double yt; // = y-dAlfaY
int iDistance, iDistance0, iDistance1;
int iDistanceMax; //, iDistanceMin;
double turn, turn0, turn1; //, turnMin;
//double dStep; // step between turns
//int iStep; // = iDistanceMax - iDistanceMin;
// compute/save turn of only one point
// translation to alfa
xt= Zx0 - dAlfaX;
yt= Zy0 - dAlfaY;
iDistance0 = (int)(sqrt(xt*xt + yt*yt)/PixelWidth);
turn0 = GiveTurn( xt, yt);
//if inside trap !! save turns to the RaysTurns array
if ( iDistance0 <= iMaxDistance2Alfa && iDistance0 >0 )
RaysTurns[iDistance0][NumberOfRay]= turn0;
// compute/save turn of only one point
// translation to alfa
xt= Zx1 - dAlfaX;
yt= Zy1 - dAlfaY;
iDistance1 = (int)(sqrt(xt*xt + yt*yt)/PixelWidth);
turn1 = GiveTurn( xt, yt);
//if inside trap !! save turns to the RaysTurns array
if ( iDistance1 <= iMaxDistance2Alfa && iDistance1 >0 )
RaysTurns[iDistance1][NumberOfRay]= turn1;
// if one of 2 ends is inside trap
// then fill the gaps ( where turn <0 ; it means not filled )
// and save turns to the RaysTurns array
if ( iDistance0 <= iMaxDistance2Alfa || iDistance1 <= iMaxDistance2Alfa)
{
// all points are not alfa ; both iDistance >0
// if ( iDistance0 >0 && iDistance1 > 0 )
/* {*/
/* iStep = iDistanceMax - iDistanceMin;*/
/* if (turn0>turn1) */
/* {dStep = (turn0-turn1)/iStep; turnMin = turn1;}*/
/* else {dStep = (turn1-turn0)/iStep; turnMin=turn0;}*/
/* for (iDistance=iMaxDistance2Alfa; iDistance<iDistance1; iDistance++) RaysTurns[iDistance][NumberOfRay] = turnMin+(iDistance-iDistance1)*dStep;*/
/* */
/* }*/
/* */
// both ends are inside trap
// one of 2 points is alfa, so one iDistance ==0
if (iDistance1==0 )
{iDistanceMax=iDistance0; turn = turn0;}
else {iDistanceMax=iDistance1; turn = turn1;}
// copy first positive value to all cells before it = straight line
for (iDistance=0; iDistance<iDistanceMax; iDistance++) RaysTurns[iDistance][NumberOfRay] = turn;
}
return 0;
}
unsigned char ComputeColor(unsigned int ix, unsigned int iy, int IterationMax)
{
// check behavour of z under fc(z)=z^2+c
// using 2 target set:
// 1. exterior or circle (center at origin and radius ER )
// as a target set containing infinity = for escaping points ( bailout test)
// for points of exterior of julia set
// 2. interior of circle with center = alfa and radius dMaxDistance2Alfa
// as a target set for points of interior of Julia set
// Z= Zx+ZY*i;
double Zx2, Zy2;
int i=0;
//int j; // iteration = fc(z)
double d2 ; /* d2= (distance from z to Alpha)^2 */
double Zxt,Zyt ; //
double Zx, Zy;
double turn;
int iDistance;
// from screen to world coordinate
Zx = GiveZx(ix);
Zy = GiveZy(iy);
/* distance from z to Alpha */
Zxt=Zx-dAlfaX;
Zyt=Zy-dAlfaY;
d2=Zxt*Zxt +Zyt*Zyt;
if (d2<dMaxDistance2Alfa2)
{
iDistance = (int)(sqrt(d2)/PixelWidth);
if (iDistance<iMaxDistance2Alfa)
{
turn = GiveTurn(Zxt, Zyt);
if ( turn>RaysTurns[iDistance][iPeriodChild-2] && turn<RaysTurns[iDistance][iPeriodChild-1])
return iColorsOfInterior[i % iPeriodChild];
}
}
// if not inside target set around attractor ( alfa fixed point )
while (1 )
{ // then iterate
Zx2 = Zx*Zx;
Zy2 = Zy*Zy;
// bailout test
if (Zx2 + Zy2 > ER2) return iColorOfExterior; // if escaping stop iteration
// if not escaping or not attracting then iterate = check behaviour
// new z : Z(n+1) = Zn * Zn + C
Zy = 2*Zx*Zy + Cy;
Zx = Zx2 - Zy2 + Cx;
//
i+=1;
/* distance from z to Alpha */
Zxt=Zx-dAlfaX;
Zyt=Zy-dAlfaY;
d2=Zxt*Zxt +Zyt*Zyt;
// check if fall into internal target set
if (d2<dMaxDistance2Alfa2)
{
iDistance = (int)(sqrt(d2)/PixelWidth);
if (iDistance<iMaxDistance2Alfa)
{
turn = GiveTurn(Zxt, Zyt);
if ( turn>RaysTurns[iDistance][iPeriodChild-2] && turn<RaysTurns[iDistance][iPeriodChild-1])
return iColorsOfInterior[i % iPeriodChild];
}
}
if (i > IterationMax) return 255;
}
return iColorsOfInterior[i % iPeriodChild]; //
}
