//----Show
void TBox::DrawBox()
{
if (m_pSprite != nullptr)
{
GfxSpriteSetPosition(m_pSprite, m_tCenter.x, m_tCenter.y);
GfxSpriteSetAngle(m_pSprite, GfxMathDegToRad(-m_fAngle));
}
//Line
if (m_pLineSprite != nullptr)
{
if (m_pLineSprite != nullptr)
GfxLineSpriteReset(m_pLineSprite);
GfxLineSpriteSetDrawingColor(m_pLineSprite, GfxColor(150, 150, 150, 255));
TGfxVec2 tAxisX = TGfxVec2(m_fRay_W, 0).Rotate(GfxMathDegToRad(m_fAngle))*m_fScale;
TGfxVec2 tAxisY = TGfxVec2(0, m_fRay_H).Rotate(GfxMathDegToRad(m_fAngle))*m_fScale;
TGfxVec2 tUR = TGfxVec2(m_tCenter.x + tAxisX.x + tAxisY.x, m_tCenter.y + tAxisX.y + tAxisY.y);
TGfxVec2 tUL = TGfxVec2(m_tCenter.x - tAxisX.x + tAxisY.x, m_tCenter.y - tAxisX.y + tAxisY.y);
TGfxVec2 tDL = TGfxVec2(m_tCenter.x - tAxisX.x - tAxisY.x, m_tCenter.y - tAxisX.y - tAxisY.y);
TGfxVec2 tDR = TGfxVec2(m_tCenter.x + tAxisX.x - tAxisY.x, m_tCenter.y + tAxisX.y - tAxisY.y);
GfxLineSpriteJumpTo(m_pLineSprite, tUL.x, tUL.y);
GfxLineSpriteLineTo(m_pLineSprite, tDL.x, tDL.y);
GfxLineSpriteLineTo(m_pLineSprite, tDR.x, tDR.y);
GfxLineSpriteLineTo(m_pLineSprite, tUR.x, tUR.y);
GfxLineSpriteLineTo(m_pLineSprite, tUL.x, tUL.y);
}
if (m_pTextSprite != nullptr)
{
GfxSpriteSetPosition(m_pTextSprite, m_tCenter.x, m_tCenter.y);
GfxSpriteSetAngle(m_pTextSprite,GfxMathDegToRad(-m_fAngle));
}
}
unsigned int TSphere::Shade(TRay & tRay, const TGfxVec3 tLight, float fDistance) const
{
TGfxVec3 tHit = tRay.m_tSrc + (tRay.m_tDir * fDistance);
TGfxVec3 tNormale = (tHit - m_tPosition).Normalize(); // Trouver le point de colison
TGfxVec3 tFromLight = (tHit - tLight).Normalize();
float fAngle = - (tFromLight.DotProduct(tNormale)); //Trouver angle entre la normale et le rayon
float fAmbiant = 0.1f;
// Clamp
if (fAngle < fAmbiant)
{
fAngle = fAmbiant;
}
// Diffuse
TGfxVec3 tColor = m_tColor;
tColor *= fAngle;
if (tColor.x > 255) tColor.x = 255;
if (tColor.x < 0) tColor.x = 0;
if (tColor.y > 255) tColor.y = 255;
if (tColor.y < 0) tColor.y = 0;
if (tColor.z > 255) tColor.z = 255;
if (tColor.z < 0) tColor.z = 0;
return GfxColor(tColor.x, tColor.y, tColor.z, 255);
}
void Initialize()
{
g_pBackground = GfxImageLoad("gfx/bg3.tga");
g_pTextureTest = GfxTextureCreate(g_pBackground);
g_pSpritesBg = GfxSpriteCreate(g_pTextureTest);
g_pTexture = GfxTextureLoad("gfx/tileset.tga"); // On crée g_pTexture ici et on l'envoie dans l'appel de fonction
g_pSpriteHero = CreateTile(g_pTexture, 7, 7, 7, 5); // Initialisée en dehors du scope pour l'utiliser autre part ( Donc on n'écrit pas "TGfxSPrite *" devant ) ( debug mode = 2, 1 | normal mode = 0, 0 )
TGfxImage * pMapImage = GfxImageLoad("gfx/map.tga"); // Pas en const car on peut vouloir la delete ( Si on le laisse comme ça, il sera inutile et prendra de la mémoire inutile ! il faut le delete après la boucle avec le destroy
int iImgSizeX = GfxImageGetSizeX(pMapImage);
int iImgSizeY = GfxImageGetSizeY(pMapImage);
for (int y = 0; y < iImgSizeY; ++y)
{
for (int x = 0; x < iImgSizeX; ++x)
{
const int iIndex = x + y * iImgSizeX;
if (GfxImageGetData(pMapImage)[iIndex] == GfxColor(255, 255, 255, 255)) // SI je veux aller voir le premier élément je dois mettre [0]
{
g_pSpriteWall[g_iWallCount] = CreateTile(g_pTexture, 6, 1, x, y); // 6 et 1 au lieu de 1 et 1 pour mur ( 1, 1 = debug mode test )
g_iWallCount++;
}
if (GfxImageGetData(pMapImage)[iIndex] == GfxColor(255, 0, 0, 255)) // SI je veux aller voir le premier élément je dois mettre [0]
{
g_pSpriteDeathWall[g_iDeathWallCount] = CreateTile(g_pTexture, 7, 1, x, y);
g_iDeathWallCount++;
}
}
}
GfxImageDestroy(pMapImage);
// for (int i = 0; i < WALL_HEIGHT; i++) !!!!!! Attention que ça doit bien s'adapter à la taille du tableau !!!!!!
// {
// g_pSpriteWall[i] = CreateTile(g_pTexture, 12, 3, 0, i);
// }
// TGfxImage Les 3 permettent d'afficher des choses.
// TGfxTexture Une image est un ensemble de pixel d'un certaine taille.
// TGfxSprite 32 bits par pixel.
// Un sprite n'est pas autonome, ça fait référence à une texture existente, il contiendra les info qui lui diront avec quelle rotation, quelle SCALE, et quelle partie de la texture utiliser ! Le sprite c'est la transformation. une partie de la texture
}
void BuildBox(TGeometry & tGeometry)
{
tGeometry.AddLine(TGfxVec3(-1, -1, -1), TGfxVec3(1, 1, -1), GfxColor(63, 63, 63, 255));
tGeometry.AddLine(TGfxVec3(-1, 1, -1), TGfxVec3(1, -1, -1), GfxColor(63, 63, 63, 255));
tGeometry.AddLine(TGfxVec3(1, 1, 1), TGfxVec3(-1, 1, 1));
tGeometry.AddLine(TGfxVec3(-1, 1, 1), TGfxVec3(-1, -1, 1));
tGeometry.AddLine(TGfxVec3(-1, -1, 1), TGfxVec3(1, -1, 1));
tGeometry.AddLine(TGfxVec3(1, -1, 1), TGfxVec3(1, 1, 1));
tGeometry.AddLine(TGfxVec3(1, 1, -1), TGfxVec3(-1, 1, -1));
tGeometry.AddLine(TGfxVec3(-1, 1, -1), TGfxVec3(-1, -1, -1));
tGeometry.AddLine(TGfxVec3(-1, -1, -1), TGfxVec3(1, -1, -1));
tGeometry.AddLine(TGfxVec3(1, -1, -1), TGfxVec3(1, 1, -1));
tGeometry.AddLine(TGfxVec3(1, 1, 1), TGfxVec3(1, 1, -1));
tGeometry.AddLine(TGfxVec3(-1, 1, 1), TGfxVec3(-1, 1, -1));
tGeometry.AddLine(TGfxVec3(-1, -1, 1), TGfxVec3(-1, -1, -1));
tGeometry.AddLine(TGfxVec3(1, -1, 1), TGfxVec3(1, -1, -1));
}
void Initialize()
{
int sizeX = (GfxGetDisplaySizeX() / 2);
int sizeY = (GfxGetDisplaySizeY() / 2);
g_pLines = GfxLineSpriteCreate();
g_pLines2 = GfxLineSpriteCreate();
ArcheoStuffs::DrawCircle(g_pLines, TGfxVec2(0, 0), 8, GfxColor(255, 255, 0, 255), true); // Player creation
for (int i = 0; i < g_iNbrCave; i++)
{
g_bCaveSearched[i] = false;
}
g_pImage = GfxImageCreate(1,1);
unsigned int * pData = GfxImageGetData(g_pImage);
*pData = EGfxColor_White;
g_pTexture = GfxTextureCreate(g_pImage);
g_pSpritePlayer = GfxSpriteCreate(g_pTexture);
g_pSpriteBase = GfxSpriteCreate(g_pTexture);
GfxSpriteSetScale(g_pSpritePlayer, 16, 16);
GfxSpriteSetColor(g_pSpritePlayer, GfxColor(255, 255, 0, 255));
g_TPlayerData.iPos = TGfxVec2(sizeX - 8, sizeY - 8);
g_TPlayerData.iPosX = sizeX - 8;
g_TPlayerData.iPosY = sizeY - 8;
GfxSpriteSetScale(g_pSpriteBase, 32, 32);
GfxSpriteSetColor(g_pSpriteBase, GfxColor(0, 255, 0, 255));
GfxSpriteSetPosition(g_pSpriteBase, sizeX-16, sizeY-16);
for (int i = 0; i < g_iNbrCave; i++)
{
ArcheoStuffs::CreateCave(i);
}
}
void TBuilding::Create(const int iPosX, const int iPosY, const int iBuildingNumber, const int SCALE)
{
this->iPosX = iPosX * SCALE;
this->iPosY = iPosY * SCALE;
TBuilding::m_tBuildingNumberSprite = GfxTextSpriteCreate();
if (iBuildingNumber < 9) // Rajoute un 0 devant les nombres plus petit que 10 pour qu'ils aient tous la même taille
{
GfxTextSpritePrintf(this->m_tBuildingNumberSprite, "0%d", (iBuildingNumber+1));
}
else
{
GfxTextSpritePrintf(this->m_tBuildingNumberSprite, "%d", (iBuildingNumber+1));
}
GfxSpriteSetFilteringEnabled(this->m_tBuildingNumberSprite, false);
GfxSpriteSetPosition(this->m_tBuildingNumberSprite, float((iPosX * SCALE) + ((SCALE / 2) - (GfxSpriteGetSizeX(this->m_tBuildingNumberSprite) / 2))),
float((iPosY * SCALE) + ((SCALE / 2) - (GfxSpriteGetSizeY(this->m_tBuildingNumberSprite) / 2))));
GfxSpriteSetColor(this->m_tBuildingNumberSprite, GfxColor(0, 0, 0, 255));
}
void Initialize()
{
g_pTexture = GfxTextureLoad("gfx/tileset.tga"); // On crée g_pTexture ici et on l'envoie dans l'appel de fonction
g_pSpriteHero = CreateTile(g_pTexture, 1, 4, 1, 1); // Initialisée en dehors du scope pour l'utiliser autre part ( Donc on n'écrit pas "TGfxSPrite *" devant )
g_pSpriteEnemy = CreateTile(g_pTexture, 8, 7, 2, 2);
TGfxImage * pMapImage = GfxImageLoad("gfx/map.tga"); // Pas en const car on peut vouloir la delete ( Si on le laisse comme ça, il sera inutile et prendra de la mémoire inutile ! il faut le delete après la boucle avec le destroy
int iImgSizeX = GfxImageGetSizeX(pMapImage);
int iImgSizeY = GfxImageGetSizeY(pMapImage);
for (int y = 0; y < iImgSizeY; ++y)
{
for (int x = 0; x < iImgSizeX; ++x)
{
const int iIndex = x + y * iImgSizeX; // Le *15 permet de compter les lignes déja parcourue ...
if (GfxImageGetData(pMapImage)[iIndex] == GfxColor(255,255,255,255)) // SI je veux aller voir le premier élément je dois mettre [0]
{
g_pSpriteWall[g_iWallCount] = CreateTile(g_pTexture, 6, 1, x, y);
g_iWallCount++;
}
}
}
GfxImageDestroy(pMapImage);
// for (int i = 0; i < WALL_HEIGHT; i++) !!!!!! Attention que ça doit bien s'adapter à la taille du tableau !!!!!!
// {
// g_pSpriteWall[i] = CreateTile(g_pTexture, 12, 3, 0, i);
// }
GfxSpriteSetPosition(g_pSpriteEnemy, -16 * SCALE, 0 * SCALE); // *4 car on a agrandi la texture X4, c'est pour avoir la même échelle
// TGfxImage Les 3 permettent d'afficher des choses.
// TGfxTexture Une image est un ensemble de pixel d'un certaine taille.
// TGfxSprite 32 bits par pixel.
// Un sprite n'est pas autonome, ça fait référence à une texture existente, il contiendra les info qui lui diront avec quelle rotation, quelle SCALE, et quelle partie de la texture utiliser ! Le sprite c'est la transformation. une partie de la texture
}
void TFade::Update()
{
if (m_eFadeState == FADING_TO_BLACK)
{
m_fOpacity += UnscaleDeltaTime() / m_fFadingDurationToBlack;
if (m_fOpacity > 1.0f){
m_fOpacity = 1.0f;
m_eFadeState = FADE_BLACK;
g_pGame->ProcessPostFadeAction();
}
}
else if (m_eFadeState == FADING_TO_CLEAR)
{
m_fOpacity -= UnscaleDeltaTime() / m_fFadingDurationToClear ;
if (m_fOpacity < 0.0f){
m_fOpacity = 0.0f;
m_eFadeState = FADE_CLEAR;
}
}
else if(m_eFadeState == FADE_BLACK)
{
m_eFadeState = FADING_TO_CLEAR;
}
#ifndef TFA_FRESH
GfxSpriteSetColor(m_pFadeSprite, GfxColor(255, 255, 255, m_fOpacity * 255.0f));
#else
lua_pushnumber(GfxFreshLuaState(), m_fOpacity);
LuaCallGlobal(GfxFreshLuaState(), "SetFadeOpacity");
#endif
}
void CreateCave(int ActCave)
{
g_pCave[ActCave].iScale = GfxMathGetRandomInteger(32, 64);
bool Collisioned = true;
do
{
g_pCave[ActCave].iPosX = (GfxMathGetRandomInteger(g_pCave[ActCave].iScale, GfxGetDisplaySizeX() - g_pCave[ActCave].iScale));
g_pCave[ActCave].iPosY = (GfxMathGetRandomInteger(g_pCave[ActCave].iScale, GfxGetDisplaySizeY() - g_pCave[ActCave].iScale));
Collisioned = false;
for (int e = 0; e < ActCave; e++)
{
if (!(g_pCave[ActCave].iPosX > g_pCave[e].iPosX + g_pCave[e].iScale + 20)
&& !(g_pCave[ActCave].iPosX < g_pCave[e].iPosX - g_pCave[ActCave].iScale - 20)
&& !(g_pCave[ActCave].iPosY < g_pCave[e].iPosY - g_pCave[ActCave].iScale - 20)
&& !(g_pCave[ActCave].iPosY > g_pCave[e].iPosY + g_pCave[e].iScale + 20))
{
Collisioned = true;
}
}
if (ActCave == 0)
{
Collisioned = false;
}
} while (Collisioned == true);
g_pCave[ActCave].pLines = GfxLineSpriteCreate();
ArcheoStuffs::DrawCircle(g_pCave[ActCave].pLines, TGfxVec2(0, 0), g_pCave[ActCave].iScale / 2, EGfxColor_Blue, false);
GfxSpriteSetPosition(g_pCave[ActCave].pLines, g_pCave[ActCave].iPosX, g_pCave[ActCave].iPosY);
g_pCave[ActCave].g_pSpriteCave = GfxSpriteCreate(g_pTexture);
GfxSpriteSetPivot(g_pCave[ActCave].g_pSpriteCave, 0.5, 0.5);
GfxSpriteSetScale(g_pCave[ActCave].g_pSpriteCave, g_pCave[ActCave].iScale, g_pCave[ActCave].iScale);
GfxSpriteSetColor(g_pCave[ActCave].g_pSpriteCave, GfxColor(0, 0, 255, 255));
GfxSpriteSetPosition(g_pCave[ActCave].g_pSpriteCave, g_pCave[ActCave].iPosX, g_pCave[ActCave].iPosY);
g_iNbrCaveCreated++;
}
void ChangeColor(int iPosX, int iPosY, int iImgSizeX)
{
GfxTextureDestroy(g_pBackgroundTexture);
GfxSpriteDestroy(g_pBackgroundSprite);
g_pData = GfxImageGetData(g_pBackgroundImage);
const int iIndex = iPosX + (iPosY * iImgSizeX);
if (g_pData[iIndex] == GfxColor(255, 0, 0, 255))
{
g_pData[iIndex] = EGfxColor_White;
}
else
{
g_pData[iIndex] = EGfxColor_Red;
}
g_pBackgroundTexture = GfxTextureCreate(g_pBackgroundImage);
g_pBackgroundSprite = GfxSpriteCreate(g_pBackgroundTexture);
GfxSpriteSetScale(g_pBackgroundSprite, 32, 32);
GfxSpriteSetFilteringEnabled(g_pBackgroundSprite, false);
}
TColor::operator unsigned int()const
{
unsigned int iRGBA = GfxColor(int(r * 255), int(g * 255), int(b * 255), int(a * 255));
return iRGBA;
}
void Initialize()
{
g_pBackgroundImage = GfxImageLoad("map.tga");
g_pData = GfxImageGetData(g_pBackgroundImage);
const int iImgSizeX = GfxImageGetSizeX(g_pBackgroundImage);
const int iImgSizeY = GfxImageGetSizeY(g_pBackgroundImage);
for (int y = 0; y < iImgSizeY; ++y)
{
for (int x = 0; x < iImgSizeX; ++x)
{
const int iIndex = x + (y * iImgSizeX);
if (g_pData[iIndex] == GfxColor(0, 0, 255, 255) || g_pData[iIndex] == GfxColor(255, 0, 0, 255) || g_pData[iIndex] == GfxColor(0, 255, 0, 255))
{
g_pData[iIndex] = EGfxColor_White;
}
}
}
g_pBackgroundTexture = GfxTextureCreate(g_pBackgroundImage);
g_pBackgroundSprite = GfxSpriteCreate(g_pBackgroundTexture);
GfxSpriteSetScale(g_pBackgroundSprite, 32, 32);
GfxSpriteSetFilteringEnabled(g_pBackgroundSprite, false);
g_pSpriteIncome = GfxTextSpriteCreate();
GfxTextSpritePrintf(g_pSpriteIncome, "revenue: $%d", g_iIncome);
GfxSpriteSetFilteringEnabled(g_pSpriteIncome, false);
GfxSpriteSetScale(g_pSpriteIncome, 2, 2);
GfxSpriteSetPosition(g_pSpriteIncome, float((GfxGetDisplaySizeX() / 2) - GfxSpriteGetSizeX(g_pSpriteIncome)), 290);
GfxSpriteSetColor(g_pSpriteIncome, GfxColor(255, 255, 255, 255));
TGfxImage * pMapImage = GfxImageLoad("map.tga");
const int iSecondImgSizeX = GfxImageGetSizeX(pMapImage);
const int iSecondImgSizeY = GfxImageGetSizeY(pMapImage);
for (int i = 0; i < 3; i++) // Boucle créant les numéros sur les buildings
{
for (int y = 0; y < iSecondImgSizeY; ++y)
{
for (int x = 0; x < iSecondImgSizeX; ++x)
{
const int iIndex = x + (y * iSecondImgSizeX);
if (i == 0)
{
if (GfxImageGetData(pMapImage)[iIndex] == GfxColor(255, 0, 0, 255)) // RED CHECKING & CREATING
{
g_tBuilding[g_iBuildingCount].Create(x, y, g_iBuildingCount, SCALE);
g_iBuildingCount++;
}
}
else if (i == 1)
{
if (GfxImageGetData(pMapImage)[iIndex] == GfxColor(0, 255, 0, 255)) // GREEN CHECKING & CREATING
{
g_tBuilding[g_iBuildingCount].Create(x, y, g_iBuildingCount, SCALE);
g_iBuildingCount++;
}
}
else if (i == 2)
{
if (GfxImageGetData(pMapImage)[iIndex] == GfxColor(0, 0, 255, 255)) // BLUE CHECKING & CREATING
{
g_tBuilding[g_iBuildingCount].Create(x, y, g_iBuildingCount, SCALE);
g_iBuildingCount++;
}
}
}
}
}
GfxImageDestroy(pMapImage);
}
