Beispiel #1
0
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);
	}
	
}
Beispiel #2
0
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 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

}
Beispiel #4
0
	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 TBox::SetTextColor(unsigned int iColor)
{
	GfxSpriteSetColor(m_pTextSprite, iColor);
}
void TBox::SetColor(const unsigned int iColor)
{
	m_iColor = iColor;
	if (m_pSprite!=nullptr)
		GfxSpriteSetColor(m_pSprite, m_iColor);
}
Beispiel #7
0
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);
}