火焰面積特性增長演算法c語言代碼

A. 計算圓面積c語言問題，代碼如下：

記住了，scanf()中double型對應的控制符必須是%lf，float型的控制符必須是%f，不然就必然出錯。而在輸出函數printf()中，在控制符%f下可以輸出任何浮點數。這些規定在教科書中都有明確儒術。

B. 幫我解釋下這段C++代碼，做火焰和熔漿效果的，

class CFireRoutine //煙火程序
{
public:
CFireRoutine(); //構造函數
virtual ~CFireRoutine(); //虛態的析構函數

// Functs (public)

void InitFire(); //初始化
void ClrHotSpots(); //清除燃燒點
void InitPallette(); //初始化調色板
void SetHotSpots(); //設置燃燒點
void MakeLines(); //生成掃描線
//渲染（視頻內存，寬度，高度）
void Render(DWORD* pVideoMemory,
int iwidth,
int iheight);

//均值（在點x,y處）（像素均值？）
unsigned char Average(int x, int y);

// props
int m_iFlameHeight; //火焰高度
int m_iWidth; //寬度
int m_iHeight;//高度（應該是作圖區高度）
//火焰來源，即從點火處的y坐標
int m_iFireSource;//The y position for the lit spots
int m_iFireChance; //燃燒幾率
int m_iAvgFlameWidth; //火焰平均寬度
int m_iAlpha; //α（深度）

COLORREF m_FireColors[4]; //火焰顏色

BYTE* m_pFireBits; //火焰數據
DWORD m_pPalletteBuffer[256]; //調色板
long* m_pYIndexes; //顏色索引
};
//熔漿：
class CPlasmaRoutine
{
public:
CPlasmaRoutine();//構造函數
virtual ~CPlasmaRoutine();//虛態析構函數

// Methods
void SetDefaultValues(VARIANT* pExtParms);//設置預設參數值（外部變數）
void InitializePlasma(VARIANT* pExtParms);//初始化岩漿參數
void Create(int iWidth,int iHeight);//按視圖生成岩漿
void Render(DWORD* pBits, //按照像素位，視圖寬度，高度，掃描線渲染
int iwidth,
int iheight,
int iLineLength);
//設置顏色索引的RGB值
void SetRGB(int iIndex,int R,int G,int B);

void InitCostBLTable(); //初始化損耗平衡表？BL是不是balance的意思啊？不知道，反正不是對比度和亮度，還是色彩飽和度？好像都不是
void InitPallette(); //初始化調色板

void CalcPlasma(); //計算岩漿
//按照顏色開始，顏色結束，顏色步長創建漸變色，存到buffer裡面
void CreateGradient(COLORREF clrStart,COLORREF clrEnd,long lSteps,COLORREF* pBuffer);

// Props

int m_iWidth;//視圖寬度
int m_iHeight;//視圖高度
int m_iAlpha;//視圖深度

BYTE* m_pPlasmaBits; //岩漿序列緩沖
DWORD m_pPalletteBuffer[256];//調色板
int m_icostbl[256];//損耗平衡表
COLORREF m_PlasmaColors[16];// Yep 16 colors needed to generate our pallete... 採用16種顏色產生調色板
//以下應該是曲線擬合用的貝塞爾曲線四個控制點和矢量坐標
unsigned char m_a1,m_a2,m_a3,m_a4,m_b1,m_b2,m_b3,m_b4;

int m_iModifier1;
int m_iModifier2;
int m_iModifier3;
int m_iModifier4;
//雙方向修改器（兩點拉拽形成的矢量）
int m_iXModifier1;
int m_iXModifier2;
int m_iYModifier1;
int m_iYModifier2;

};

// FireRoutine.cpp: implementation of the CFireRoutine class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "FireRoutine.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction 構造函數，初始化所有參數，注意火源初始值為2，燃燒概率初始值為10
//////////////////////////////////////////////////////////////////////

CFireRoutine::CFireRoutine()
{
m_iWidth = 0;
m_iHeight = 0;
m_pFireBits = NULL;
m_pYIndexes = NULL;
m_iFireSource = 2;
m_iFireChance = 10;
m_iFlameHeight = 50;
m_iAlpha = 255;

m_FireColors[0] = RGB(0,0,0);// Black
m_FireColors[1] = RGB(255,0,0);// Red
m_FireColors[2] = RGB(255,255,0);// Yellow
m_FireColors[3] = RGB(255,255,255);// White
m_iAvgFlameWidth = 35;
}

//析構函數，如果顏色索引和渲染緩沖區存在則注銷
CFireRoutine::~CFireRoutine()
{
if(m_pFireBits != NULL)
delete [] m_pFireBits;

if(m_pYIndexes != NULL)
delete [] m_pYIndexes;

m_pFireBits = NULL;
m_pYIndexes = NULL;
}
void CFireRoutine::InitFire()
{
// Get Rid of anything already there 初始化火焰，如果存在顏色索引和渲染緩沖則首先注銷
if(m_pFireBits != NULL)
delete [] m_pFireBits;

if(m_pYIndexes != NULL)
delete [] m_pYIndexes;

// Add three to the height 高度自動加三
m_iHeight+=3;

m_pYIndexes = new long[m_iHeight]; //顏色索引時以火焰高度為長度的一個長整形數組

m_pFireBits = new BYTE[m_iWidth*m_iHeight]; //渲染緩沖區為一個W*H長度的字元型數組

// Clear the Fire bits 將火焰緩沖區置零
memset(m_pFireBits,0,(m_iWidth*m_iHeight));
// do all the y index pre-calc.. 在計算之前先將顏色緩沖值初始化為每個元素=寬度*高度
for (int y = m_iHeight; y >0; y--)
m_pYIndexes[y] = y * m_iWidth;

// Create our pallete

InitPallette(); //初始化調色板
ClrHotSpots(); //清除燃燒點

}
//所謂清除燃燒點就是將渲染緩沖區的某一行清零。哪一行呢？就是顏色索引中火源指向的那一行。
void CFireRoutine::ClrHotSpots()
{
// clear the fire line
memset(&m_pFireBits[m_pYIndexes[m_iFireSource]],0,m_iWidth);
}

//初始化調色板。您可能需要首先了解一下調色板的概念：雖然一個圖可能是彩色的，但是每個像素如果
//都按照RGB三個位元組方式存儲，則成本太高了。調色板在於，假設這個圖還是彩圖，但是經過色彩分析，
//其中只有256種顏色是圖中的常用顏色，這樣一個位元組就可以代表一個像素了，不過這個位元組的值指的
//並不是RGB這種色彩矢量，而是256種顏色的代碼，這256種顏色就是這幅圖的調色板。
void CFireRoutine::InitPallette()
{
// Create a gradient between all the colors we have for our fire... 為我們的火焰創造一個過渡色使用的所有顏色

long iCount = 0;
COLORREF clrStart;
COLORREF clrEnd;

for(int iColor = 1;iColor<4;iColor++) //火焰的四個顏色定義
{

clrStart = m_FireColors[iColor-1]; //設置過渡色的起始顏色
clrEnd = m_FireColors[iColor]; //設置過渡色的終止顏色

int r, g, b; // First distance, then starting value 先計算距離，再計算值
float rStep, gStep, bStep; // Step size for each color //每種顏色的過渡步進值

// Get the color differences 取得三個顏色RGB的起始顏色和過渡顏色色差
r = (GetRValue(clrEnd) - GetRValue(clrStart));
g = (GetGValue(clrEnd) - GetGValue(clrStart));
b = (GetBValue(clrEnd) - GetBValue(clrStart));

int nSteps = max(abs(r), max(abs(g), abs(b))); //過渡步長數量取為RGB紅綠藍中色差最大者
float fStep = (float)(255/3)/ (float)nSteps; //將色差步長值轉換為浮點數
// Calculate the step size for each color
rStep = r/(float)nSteps;//求得各顏色分量的色差步長值
gStep = g/(float)nSteps;
bStep = b/(float)nSteps;

// Reset the colors to the starting position 將顏色設置為漸進色初始顏色
r = GetRValue(clrStart);
g = GetGValue(clrStart);
b = GetBValue(clrStart);

for (int iOnBand = 0; iOnBand < nSteps; iOnBand++) //按照RGB計算出在漸變色全程中每個顏色的實際值
{
//COLORREF color = RGB(r+rStep*iOnBand, g + gStep*iOnBand, b + bStep *iOnBand);
COLORREF color = RGB(b + bStep *iOnBand, g + gStep*iOnBand,r+rStep*iOnBand);

long lIndex = (int)(iOnBand * fStep);

if(lIndex+((iColor-1)*85) < 255)
m_pPalletteBuffer[lIndex+((iColor-1)*85)] = color; //計算結果放到調色板裡面去
}
}
// Step on the second color a little bit...向終止顏色過渡，以下顏色生成的內容與上面基本一致。
clrStart = m_FireColors[0];
clrEnd = m_FireColors[1];

for(int kj=0;kj<m_iFlameHeight;kj++)
m_pPalletteBuffer[kj] = 0;

int r, g, b; // First distance, then starting value
float rStep, gStep, bStep; // Step size for each color

// Get the color differences
r = (GetRValue(clrEnd) - GetRValue(clrStart));
g = (GetGValue(clrEnd) - GetGValue(clrStart));
b = (GetBValue(clrEnd) - GetBValue(clrStart));

int nSteps = max(abs(r), max(abs(g), abs(b)));
float fStep = (float)(85-m_iFlameHeight)/ (float)nSteps;
// Calculate the step size for each color
rStep = r/(float)nSteps;
gStep = g/(float)nSteps;
bStep = b/(float)nSteps;

// Reset the colors to the starting position
r = GetRValue(clrStart);
g = GetGValue(clrStart);
b = GetBValue(clrStart);

for (int iOnBand = 0; iOnBand < nSteps; iOnBand++)
{
//COLORREF color = RGB(r+rStep*iOnBand, g + gStep*iOnBand, b + bStep *iOnBand);
COLORREF color = RGB(b + bStep *iOnBand, g + gStep*iOnBand,r+rStep*iOnBand);

long lIndex = (int)(iOnBand * fStep);

m_pPalletteBuffer[lIndex+(85-m_iFlameHeight)] = color; //填寫顏色值
}

}
// Macro to get a random integer within a specified range */ 這是一個按照范圍取隨機數的宏
#define getrandom( min, max ) (( rand() % (int)((( max ) + 1 ) - ( min ))) + ( min ))
#include <time.h>

void CFireRoutine::SetHotSpots() //設置燃燒點
{
ClrHotSpots(); //首先清除燃燒點
//m_iAvgFlameWidth

long lPosition = 0; //按照橫軸位置進行累加，直到抵達寬度界限
while(lPosition < m_iWidth)
{
// see if we should do a flame
if (getrandom(0,100) < m_iFireChance) //得到一個隨機數，看看是不是在燃燒概率范圍內，如果不是就跳過去
{
// get a flame width
long lFlameWidth = getrandom(1,m_iAvgFlameWidth); //隨機取得一個火焰寬度
for(int i=0;i<lFlameWidth;i++)
{
if(lPosition < m_iWidth) //如果位置在屏幕范圍內，設置一個燃燒點
{
m_pFireBits[m_pYIndexes[m_iFireSource]+lPosition] =254;// set a hot spot!
lPosition++;
}
}
}
lPosition++;
}
// for (x = 0; x < m_iWidth; x++)
// {
// if (getrandom(0,100) < m_iFireChance)
// {

// }
// }
}

void CFireRoutine::MakeLines() //生成渲染掃描線
{
int x, y;

for (x = 0; x < m_iWidth; x++) //橫向循環，從屏幕左側到右側
{
for (y = m_iFireSource; y<m_iHeight-1;y++) //縱向循環，從火源到火焰高度
// for (y = m_iHeight; y > m_iFireSource; y--)
{
//m_pFireBits[m_pYIndexes[y-1]+x] =Average(x,y);
m_pFireBits[m_pYIndexes[y+1]+x] =Average(x,y); //火焰值為掃描線均值
}
}
}
unsigned char CFireRoutine::Average(int x, int y)
{

unsigned char ave_color;
unsigned char ave1, ave2, ave3, ave4, ave5, ave6, ave7;

// Make sure we are not at the last line... 只要不是掃描線最後一樣，平均值按照下列方式計算。
if(y == m_iHeight)
ave1 = m_pFireBits[m_pYIndexes[y-1] + x];
else
ave1 = m_pFireBits[m_pYIndexes[y + 1] + x];
//掃描線均值的方法，以x,y為中心，小半徑為1，大半徑為2的橫向橢圓，從這個范圍內取得顏色，然後求均值：
//基本上是下面這個圖的樣式：格式：取點編號（坐標）
/*
1#(x, y+1)
6#(x-2, y) 4#(x-1, y) 7#(x,y) 3#(x+1, y) 5#(x+2, y)
2#(x, y-1)
*/

ave2 = m_pFireBits[m_pYIndexes[y - 1] + x];
ave3 = m_pFireBits[m_pYIndexes[y] + x + 1];
ave4 = m_pFireBits[m_pYIndexes[y] + x - 1];
ave5 = m_pFireBits[m_pYIndexes[y] + x + 2];
ave6 = m_pFireBits[m_pYIndexes[y] + x - 2];
ave7 = m_pFireBits[m_pYIndexes[y] + x];

ave_color = (ave1 + ave2 + ave3 + ave4 + ave5 + ave6 + ave7) / 7;

//求出顏色均值並返回
return(ave_color);
}

//按照視頻內存進行渲染
void CFireRoutine::Render(DWORD* pVideoMemory,
int iwidth,
int iheight
)
{
SetHotSpots(); // generate random hotspots 產生燃燒點
MakeLines(); // do all the math and screen updating //產生掃描線，更新屏幕

// Right now Im just going to blit it right onto the video memory //向視頻內存做BitBlt緩沖拷貝
unsigned char* pSrcBitlin;// = m_pFireBits+(m_iWidth*3);// get rid of our fire source //獲取火源
BYTE *dst;//=(BYTE*)Dib->pVideoMemory;

BYTE r;
BYTE g;
BYTE b;

for(int i=0;i<m_iHeight-3;i++) //逐行掃描
{
dst = (BYTE*)&pVideoMemory[(iwidth*i)]; //取得視頻當前行
pSrcBitlin =&m_pFireBits[m_pYIndexes[i+3]]; //設置掃描線數據指針

for(int x=0;x<m_iWidth;x++)
{
//合成顏色，注意，是索引顏色取RGB分量後加上深度和飽和度，移位
r = GetRValue(m_pPalletteBuffer[pSrcBitlin[x]]);
g = GetGValue(m_pPalletteBuffer[pSrcBitlin[x]]);
b = GetBValue(m_pPalletteBuffer[pSrcBitlin[x]]);

dst[0]=(BYTE)(((r-dst[0])*m_iAlpha+(dst[0]<<8))>>8);
dst[1]=(BYTE)(((g-dst[1])*m_iAlpha+(dst[1]<<8))>>8);
dst[2]=(BYTE)(((b-dst[2])*m_iAlpha+(dst[2]<<8))>>8);
dst+=4;
}
}

}
關於岩漿和水波的源代碼，概念差不多，都是首先建立顏色模型、然後匹配到緩沖中去，仔細對比一下就看懂了

C. 求一個C語言問題：我的代碼如下，這樣的題有專門的演算法嗎

似乎程序里有問題

//1.沒看到b的初始化
// 2. printf裡面，x也是變數，不是字元常量

寫個很直接的文字演算法給你

//a[ ]是應到課人員名單，b[ ]是實際到課人員名單的話
//對於每一個a[i]

//應該是看a[i]是否在b[]里出現對吧。也就是說，在實際到課名單里b[ ]中搜索一個應該到課的學生a[i]，如果找到，則不用列出這個名字，否則輸出這個名字。而且需要每個蹺課的人（b中找不到的人）都輸出。
//所以：你的兩層循環變數沒有問題

//但是進入循環前 需要一個bool值NOTFound作為找到與否的標志，默認為真。
// 因為要和每一個b中的值進行比較,所以不到最後不知道是否缺課，
// 如果某個b[j]和a[i]相同

// 則置NOTFound為假，否則不變。
// 內層循環結束後，
// 如果NOTFound為真，輸出這個名字，即輸出a[i]
// 然後重置NOTFound為真.

如果不進行預排列，這個需要查找每個元素的演算法，時間復雜度是O(n*n)，雙循環嘛，呵呵 。
你如果用open hash表一開始就對輸入的數據b[]進行排序和優化的話，比如前面有人說到的按首字母建立靜態數組，第0位代表字母a,第1位代表字母b，以此類推。然後首字母相同的單詞鏈接在數組對應的位置後面，那麼查找部分的效率可以變成接近O(n)。但是前面需要一些輔助函數，比如把字元轉化為數值，以及對節點的定義和鏈表的操作。

D. c語言編程題任意輸入一個長方形的長度與寬度值，編程求其面積。要求長，寬均為整型

依次在計算機中輸入以下代碼：
#include <stdio.h>void main(){int x,y;printf("請輸入長:\n");scanf("%d",&x);printf("請輸入寬:\n");scanf("%d",&y);
printf("周長: %d\n",2*(x+y));printf("面積: %d\n",x*y);}以上就是整個長方形周長面積求解過程。

E. 火焰紋章 火焰紋章多拉基亞776這個游戲的c語言代碼是多少麻煩網友幫我找一下好嗎謝謝!

這個不是商業機密嘛……雖然年代久遠，但只要任天堂還正常就不會公開代碼的吧……
再說了，不一定是用C編的，原游戲只有4MB，用C的話不止這點吧
戰斗流程可以參考一下游戲的計算公式和各種武器相剋、地形修正等等，大致就推出戰斗判定時調用的函數了吧
玩家AI行動時用的大概是A*演算法等等尋路演算法，AI的行動規則大概就是評分值，按照評分的高低選擇行動的模式，比如將攻擊主角記為9分，攻擊較弱的角色10分之類
還有最最重要的亂數表，就是從亂數表中取出一個隨機數，從而判定命中、升級成長之類的……
總之分析一下的話，整個系統就能大致推敲出來，真要源代碼很抱歉，真沒有。

F. 求c語言 演算法 求大神的代碼

說白了這道題是數學題，首先要知道位數越多，值越大，那麼也就是說在兩個加號之間的位數越小，值就越小。
假設串的長度為size
那麼1:如果M+1被串的長度整除，這個最簡單，直接把這個串平分分成M+1分，在中間加入+號，也就是在size/(M+1)+(size/(M+1)+1)*i, i=0,1,2...處插入加號
但是不是所有的M+1都能被size整除，在不能被整除的情況下，先算出size/(M+1)的值，假設等於m1，再算出size%M的值，假設等於m2.這時候這個算式得到一個值，這種情況初始就是把加號加在m1+(m1+1)*i處，
for(j=0,j<m2,++j)
{
找出最小的一個數，將該數右邊的加號依次右移一位}
大致邏輯應該是這樣的吧

G. C語言演算法問題，求解大佬解決，給出代碼

#include "stdafx.h"
#include <stdio.h>

//定義矩陣大小
#define ROWCNT 3 //行
#define COLCNT 4 //列

typedef struct{
int row; //行，-1表表示未定義，0表示第一行
int col; //列，-1表表示未定義，0表示第一列
int val; //值
} Elem;

extern Elem A[ROWCNT*COLCNT];
extern Elem B[ROWCNT*COLCNT];
extern Elem Sum[ROWCNT*COLCNT];

void input(Elem *Data){
int row,col,val;
int cnt=0;
//先對數組初始化
for(cnt=0;cnt<ROWCNT*COLCNT;cnt++){
Data[cnt].row=-1;
Data[cnt].col=-1;
Data[cnt].val=0;
}

cnt=0;
do{
scanf("%d %d %d",&row,&col,&val);
if (row>=0){

Data->row=row;
Data->col=col;
Data->val=val;
Data++;//指針後移到下一個元素
cnt++;
}
}while((row>=0)&&(cnt<ROWCNT*COLCNT));
}

int Find(Elem *Data,int row,int col){
int result=0;
while(Data->row>=0){
if ((Data->row==row)&&(Data->col==col)){
result=Data->val;
break;
}
Data++;
}
return(result);
}

void ShowMatrix(Elem *A){
int i,j;
for(i=0;i<ROWCNT;i++){
for(j=0;j<COLCNT;j++){
printf("%d ",Find(A,i,j));
}
printf("\n");
}
}

void AddMatric(Elem *DataA,Elem *DataB,Elem *DataSum){
int i,j,k;
for(i=0;i<ROWCNT;i++){
for(j=0;j<COLCNT;j++){
k=Find(DataA,i,j)+Find(DataB,i,j);
if(k!=0){
DataSum->row=i;
DataSum->col=j;
DataSum->val=k;
DataSum++;
}
}
}
}

int main(int argc, char* argv[]){
printf("Input Matrix A \n");
printf("Format: Row Col Value\n");
printf("when Row=-1 to end\n");
input(A);
printf("---Matrix A is ----\n");
ShowMatrix(A);

printf("\nInput Matrix B \n");
printf("Format: Row Col Value\n");
printf("when Row=-1 to end\n");
input(B);
printf("---Matrix B is ----\n");
ShowMatrix(B);

AddMatric(A,B,Sum);

printf("---Matrix Sum is ----\n");

ShowMatrix(Sum);

scanf("%d",&i);//等待輸入一個數字，方便在調試時觀察結果，否則會運行完成直接退出，不容易看到輸出
return 0;
}

H. C語言問題，編寫一個程序計算矩形的面積和周長

1.代碼參考：（邊長可以是整數也可以是小數；實現乘法的運算符是*）

(8)火焰面積特性增長演算法c語言代碼擴展閱讀

1.結構類型是在程序中定義的類型，以指定記錄的格式，它包括成員名稱和類型，以及成員在內存中的存儲次序。

2.一旦定義了結構類型，就可以像使用其他所有類型一樣使用這種結構類型，可以聲明具有這種結構類型的對象，定義指向這種對象的指針，以及定義具有這種結構類型元素的數組。

3.結構類型的定義從關鍵字 struct 開始，大括弧內包含聲明結構成員的列表：struct [標簽名稱] {成員聲明列表}；

4.結構必須包含至少一個成員。下面的例子定義了 struct Date 類型，它有 3 個 short 類型的成員：struct Date { short month, day, year; }；

5.標識符Date是該結構類型的標簽（tag）。標識符 year、month 和 day 是成員名稱。

6.結構類型的標簽屬於一個不同的命名空間：即使結構標簽與變數名或函數名相同，編譯器也仍然可以區分。類似地，對於每個結構類型，其中的每個結構成員名稱都屬於不同的命名空間。

7.結構的成員，可以定義為任何所需的完整類型，包括之前已定義的結構類型。但是不能是長度可變的數組，或者指向長度可變數組的指針。

I. 解釋一下這段C語言代碼的具體演算法 解釋的好的追加分啊！

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <string.h>

void encrypt(char *in, char *pwd, char *out)
//簡單說這個函數是將文件in復制到文件out,中間使用pwd密碼編碼
{
FILE *infile, *outfile;
char ch;
int i=0, PwdLen=0;
if ((infile=fopen(in, "rb"))==NULL) //判斷文件存在創建
{
printf("無法打開 %s\n", in);
getch();
exit(1);
}
if ((outfile=fopen(out, "wb"))==NULL) //判斷文件存在創建
{
printf("無法打開或創建 %s\n", out);
getch();
exit(1);
}
while (pwd[PwdLen++]); //這里用來應付密碼為空的情況
PwdLen--;
ch=fgetc(infile);
while (!feof(infile))
{
fputc(ch^pwd[i>=PwdLen?i=0:i++], outfile); //讀文件in內容編碼後寫到out
ch=fgetc(infile);
}
fclose(infile);
fclose(outfile);
}

int main(int argc, char *argv[])
{
char in[256];
char out[256];
char pwd[256];
if (argc!=4)
{
printf("要加／解密的文件：\n");
gets(in);
printf("密碼：\n");
gets(pwd);
printf("輸出文件：\n");
gets(out);
encrypt(in, pwd, out);
}
else encrypt(argv[1], argv[2], argv[3]);
}

J. 如何用C語言製作一個3D的動態火焰效果

嗯，我來說兩句。
C語言是可以實現火焰粒子特效的
你的創作思路是：在網上搜集關於火焰粒子特效的文章，比如網路文庫，新浪文庫、
然後著手編程
編程要注意，既然是C，你可以包含DirectX的庫，然後調用別人寫好的庫函數實現一些基本功能，比如畫點，上色，定時，Z緩存，你可以搜directx的使用說明，多得很
動態火焰效果是游戲編程的一部分，額。。涉及挺多的東西，代碼無法給你，抱歉