魔兽3自适应地块贴图算法

整个贴图过程分为4个步骤:
1. 删除地块
2. 拼接地块
3. 排序地块层
4. 更新地块

有2种类型的地形纹理:

根据上面这张排好索引的图片,加上效果图可以知道基本地块为:
1 | 2
8 | 16
然后是随机地块,数据如下:
s32 s_pBaseTexIndex_c[] = { 1, 2, 8, 16 };
s32 s_pRandTexIndex_c[] = { 0, 4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 27, 28, 29, 30, 31 };

整个贴图算法都是基于上面这个基本索引而来.4个基本索引相加为27,是一个很特别的索引.

举2个例子:

1 |  2+1           1 | 3

8 | 16+8 =       8 | 24 =

1     | 2                 1 | 2

8+1 | 16+2 =       9 | 18 =

一个格子最多可以贴4个地块,也就是4层地块,下面是基本数据定义.

// 地形顶点数据
struct TeVertex
{
         f32            fHeight;          ///< 地形高度值
         Vector3f v3Normal; ///< 地形顶点法向量
};

// 地形地块纹理数据
struct TeTile
{
         s8 Block[TE_TILE_COUNT]; ///< 纹理中的一块
         u8 Texture[TE_TILE_COUNT]; ///< 纹理ID,255代表空
};

首先初始化一个32*32的地形数据:

m_pVertex = new TeVertex[32*32];
m_pTile = new TeTile[32*32];

for( i = 0; i < 32*32; ++i )
{
       nBlock = s_pRandTexIndex_c[rand() % 18];

       m_pVertex[i].fHeight = 0.0f;

       m_pTile[i].Block[0] = nBlock;
       m_pTile[i].Texture[0] = 0;

       m_pTile[i].Block[1] = 0;
       m_pTile[i].Texture[1] = 255;

       m_pTile[i].Block[2] = 0;
       m_pTile[i].Texture[2] = 255;

       m_pTile[i].Block[3] = 0;
       m_pTile[i].Texture[3] = 255;
}

在拼接之前首先是找出4个要拼接的格子,如图:

1. 删除地块
         1-1: 如果当前地块第0层的纹理索引不为0并且Block索引是随机地块的话,格子的数据需要调整, 算法为用27减去除第0层外所有有效层的Block索引,最后的结果赋予第0层的Block.
   
         1-2: 循环直到找出如果4个格子的某一层的Texture索引都相同,并找出所在的层,然后在做以下判断:
              1-2-1: 如果这4个格子的这4层的Block索引都是随机地块索引,并且Texture索引比要贴的Texture索引大的话,则这4个格子的相应Block索引都要变为27减去基本索引. 然后回到2-1.
        
              1-2-2: 1-2-1不成立的话,判断4个格子的Block是否可删除,条件是用当前地块的当前层的Block索引减去基本地块,如果是随机地块索引(除开0和27)则不合法,其余结果是合法的.
        
              1-2-3: 将4个格子的对应层的Block索引都减去一个值.如果是Block索引是随机地块索引，则用27减去基本地块索引.否则用自身的Block索引减去基本索引值,如果减出来的结果是0的话, 则设置这个格子的这一层的Texture索引为255

2. 拼接地块
         首先是找出要拼接纹理对应的层次,这中间涉及到调节层次数据,看下面的代码.接下来就是修改Block索引,主要的操作就是加上基本索引.在这中间涉及到的判断相当的多,还是看代码直接:),值得注意的是当设置的地块Block索引为27的时候需要特殊处理.

3. 排序地块层
         这一步最简单,一共才4层,最简单的冒泡排序就行了:)

4. 更新地块
         把一个地块中所有的地块索引相加,索引为随机地块的不参与,如果最后的结果为27那么需要对这个地块的数据做调整.如果这个格子的Texture索引不是0的话,把这个格子的第0层的Block索引设置为随机地块索引.如果是0的话,则第0层的Texture索引变为第1层的Texture索引,并且把第2层的数据复制到第1层,把第3层的数据复制到第2层,第3层的数据设置为空.
   
         由于网上查不到相关的资料,上面这些都是我通过观察war3的编辑器总结出来的,希望可以给在做类似war3这种地形贴图的朋友一些帮助:),有不明白的地方可以在QQ(76537477)上联系我.

最后贴上我的效果图和核心代码:


算法的基本代码(为了简单明了,下面的代码是简化了的, 这里实在是不知道怎么排版啊)

 

 

 

1.  #define  TE_TILE_COUNT     4 
2.  #define  TE_INVALID_TILE   255 
3.  #define  TE_TILE_LEN       2.0f 
4.  #define  TE_TEX_BASE       4  //  地形纹理基本变换数 
5.  #define  TE_MAX_TEX        8  //  地形最多支持8种不同的纹理 
6.  #define  TE_TEX_RAND_S     2  //  256的地形纹理最大变换数 
7.  #define  TE_TEX_RAND_C     18  //  512的地形纹理最大变换数 
8.  #define  TE_TEX_COUNT_S    16  //  Simple 
9.  #define  TE_TEX_COUNT_C    32  //  Complex//-------------&------------- 
10.  // ---------------------------&------------------------- 
11.  void  SetTile(  const  Vector3f  & v3Pos )
12.   {
13.  if ( m_nSelectTexture  <   0   ||  m_nSelectTexture  >=  m_vecTexture.Size() )
14.       return ;
15. f32 fDis  =  TE_TILE_LEN  /   2.0f ;
16. s32 nLDTile  =  (s32)((v3Pos.y  -  fDis)  /  TE_TILE_LEN)  *  m_nTileWid  +  (s32)((v3Pos.x  -  fDis)  /  TE_TILE_LEN);
17. s32 nRDTile  =  (s32)((v3Pos.y  -  fDis)  /  TE_TILE_LEN)  *  m_nTileWid  +  (s32)((v3Pos.x  +  fDis)  /  TE_TILE_LEN);
18. s32 nRUTile  =  (s32)((v3Pos.y  +  fDis)  /  TE_TILE_LEN)  *  m_nTileWid  +  (s32)((v3Pos.x  +  fDis)  /  TE_TILE_LEN);
19. s32 nLUTile  =  (s32)((v3Pos.y  +  fDis)  /  TE_TILE_LEN)  *  m_nTileWid  +  (s32)((v3Pos.x  -  fDis)  /  TE_TILE_LEN);
21. s32 i  =   0 , nLDLayer  =   0 , nRDLayer  =   0 , nRULayer  =   0 , nLULayer  =   0 ;
22. s32 nLDBlock, nRDBlock, nRUBlock, nLUBlock;
23. BOOL bLDCheck  =  FALSE, bRDCheck  =  FALSE, bRUCheck  =  FALSE, bLUCheck  =  FALSE; //  更新当前周围的地块属性 
25. UpdateTileAttribute( nLDTile, nRDTile, nRUTile, nLUTile );  //  找出对应的层 
26.  for ( i  =   0 ; i  <  TE_LAYERS;  ++ i )
27.   {
28.       if ( m_pTile[nLDTile].Texture[i]  ==  m_nSelectTexture )
29.        {
30.       nLDLayer  =  i;
31.       bLDCheck  =  TRUE;
32.      } 
33.       else   if (  ! bLDCheck  &&  m_pTile[nLDTile].Texture[i]  !=  TE_INVALID_TILE )
34.        {
35.        ++ nLDLayer;
36.      }      
37.       if ( m_pTile[nRDTile].Texture[i]  ==  m_nSelectTexture )
38.        {
39.       nRDLayer  =  i;
40.       bRDCheck  =  TRUE;
41.      } 
42.       else   if (  ! bRDCheck  &&  m_pTile[nRDTile].Texture[i]  !=  TE_INVALID_TILE )
43.        {
44.        ++ nRDLayer;
45.      }      
46.       if ( m_pTile[nRUTile].Texture[i]  ==  m_nSelectTexture )
47.        {
48.       nRULayer  =  i;
49.       bRUCheck  =  TRUE;
50.      } 
51.       else   if (  ! bRUCheck  &&  m_pTile[nRUTile].Texture[i]  !=  TE_INVALID_TILE )
52.        {
53.        ++ nRULayer;
54.      }      
55.       if ( m_pTile[nLUTile].Texture[i]  ==  m_nSelectTexture )
56.        {
57.       nLULayer  =  i;
58.       bLUCheck  =  TRUE;
59.      } 
60.       else   if (  ! bLUCheck  &&  m_pTile[nLUTile].Texture[i]  !=  TE_INVALID_TILE )
61.        {
62.        ++ nLULayer;
63.      } 
64. } 
65.       if (  ! bLDCheck )
66.      nLDLayer  =  AdjustTileLayer( nLDTile,  2  );
67.       if (  ! bRDCheck )
68.      nRDLayer  =  AdjustTileLayer( nRDTile,  3  );
69.       if (  ! bRUCheck )
70.      nRULayer  =  AdjustTileLayer( nRUTile,  1  );
71.       if (  ! bLUCheck )
72.      nLULayer  =  AdjustTileLayer( nLUTile,  0  );
73. s32 nLDTexture  =  m_pTile[nLDTile].Texture[nLDLayer];
74.  if ( nLDTexture  !=  TE_INVALID_TILE )
75.   {
76.      s32 nRDTexture  =  m_pTile[nRDTile].Texture[nRDLayer];
77.      s32 nRUTexture  =  m_pTile[nRUTile].Texture[nRULayer];
78.      s32 nLUTexture  =  m_pTile[nLUTile].Texture[nLULayer]; 
79.      if ( nLDTexture  ==  nRDTexture  &&  nLDTexture  ==  nRUTexture  &&  nLDTexture  ==  nLUTexture )
80.        {
81.        if ( (m_pTile[nLDTile].Texture[TE_LAYERS - 1 ]  !=  TE_INVALID_TILE  ||  
82.           m_pTile[nRDTile].Texture[TE_LAYERS - 1 ]  !=  TE_INVALID_TILE  || 
83.           m_pTile[nRUTile].Texture[TE_LAYERS - 1 ]  !=  TE_INVALID_TILE  || 
84.           m_pTile[nLUTile].Texture[TE_LAYERS - 1 ]  !=  TE_INVALID_TILE) )
85.         {
86.         if ( (nLDTexture  ==  m_nSelectTexture)  &&  
87.            (m_pTile[nLDTile].Block[nLDLayer]  ==  s_pBaseTexIndex_c[ 2 ]  || 
88.             m_pTile[nRDTile].Block[nRDLayer]  ==  s_pBaseTexIndex_c[ 3 ]  ||  
89.             m_pTile[nRUTile].Block[nRULayer]  ==  s_pBaseTexIndex_c[ 1 ]  ||  
90.             m_pTile[nLUTile].Block[nLULayer]  ==  s_pBaseTexIndex_c[ 0 ] ) )
91.          {
92.          goto  _SORT_LAYER;
93.        }        nLDBlock  =  m_pTile[nLDTile].Block[nLDLayer];
94.         if ( m_pTile[nLDTile].Texture[nLDLayer]  !=   0   &&  (nLDBlock  ==   0   ||   ! IsValidRandBlock(nLDBlock)) )
95.         nLDBlock  =  m_pTile[nLDTile].Block[nLDLayer]  +  s_pBaseTexIndex_c[ 2 ];       nRDBlock  =  m_pTile[nRDTile].Block[nRDLayer];
96.         if ( m_pTile[nRDTile].Texture[nRDLayer]  !=   0   &&  (nRDBlock  ==   0   ||   ! IsValidRandBlock(nRDBlock)) )
97.         nRDBlock  =  m_pTile[nRDTile].Block[nRDLayer]  +  s_pBaseTexIndex_c[ 3 ];       nRUBlock  =  m_pTile[nRUTile].Block[nRULayer];
98.         if ( m_pTile[nRUTile].Texture[nRULayer]  !=   0   &&  (nRUBlock  ==   0   ||   ! IsValidRandBlock(nRUBlock)) )
99.         nRUBlock  =  m_pTile[nRUTile].Block[nRULayer]  +  s_pBaseTexIndex_c[ 1 ];       nLUBlock  =  m_pTile[nLUTile].Block[nLULayer];
100.         if ( m_pTile[nLUTile].Texture[nLULayer]  !=   0   &&  (nLUBlock  ==   0   ||   ! IsValidRandBlock(nLUBlock)) )
101.         nLUBlock  =  m_pTile[nLUTile].Block[nLULayer]  +  s_pBaseTexIndex_c[ 0 ];        if ( IsValidBlock(nLDBlock)  &&  IsValidTileBlock( nLDBlock ) )
102.         SetTileAttribute( nLDTile, nLDLayer, nLDBlock );
103.     
104.         if ( IsValidBlock(nRDBlock)  &&  IsValidTileBlock( nRDBlock ) )
105.         SetTileAttribute( nRDTile, nRDLayer, nRDBlock );
106.     
107.         if ( IsValidBlock(nRUBlock)  &&  IsValidTileBlock( nRUBlock ) )
108.         SetTileAttribute( nRUTile, nRULayer, nRUBlock );
109.     
110.         if ( IsValidBlock(nLUBlock)  &&  IsValidTileBlock( nLUBlock ) )
111.         SetTileAttribute( nLUTile, nLULayer, nLUBlock );        goto  _SORT_LAYER;
112.       } 
113.        else   if ( m_pTile[nLDTile].Block[nLDLayer]  +  s_pBaseTexIndex_c[ 2 ]  >=  TE_TEX_COUNT_C  || 
114.         m_pTile[nRDTile].Block[nRDLayer]  +  s_pBaseTexIndex_c[ 3 ]  >=  TE_TEX_COUNT_C  || 
115.         m_pTile[nRUTile].Block[nRULayer]  +  s_pBaseTexIndex_c[ 1 ]  >=  TE_TEX_COUNT_C  || 
116.         m_pTile[nLUTile].Block[nLULayer]  +  s_pBaseTexIndex_c[ 0 ]  >=  TE_TEX_COUNT_C )
117.         {
118.         goto  _SORT_LAYER;
119.       } 
120.      } 
121. }
122.     nLDBlock  =  m_pTile[nLDTile].Block[nLDLayer]  +  s_pBaseTexIndex_c[ 2 ];
123. nRDBlock  =  m_pTile[nRDTile].Block[nRDLayer]  +  s_pBaseTexIndex_c[ 3 ];
124. nRUBlock  =  m_pTile[nRUTile].Block[nRULayer]  +  s_pBaseTexIndex_c[ 1 ];
125. nLUBlock  =  m_pTile[nLUTile].Block[nLULayer]  +  s_pBaseTexIndex_c[ 0 ]; if (  ! IsValidTileBlock( nLDBlock ) )
126.       goto  _SORT_LAYER; if (  ! IsValidTileBlock( nRDBlock ) )
127.       goto  _SORT_LAYER; if (  ! IsValidTileBlock( nRUBlock ) )
128.       goto  _SORT_LAYER; if (  ! IsValidTileBlock( nLUBlock ) )
129.       goto  _SORT_LAYER;SetTileAttribute( nLDTile, nLDLayer, nLDBlock );
130. SetTileAttribute( nRDTile, nRDLayer, nRDBlock );
131. SetTileAttribute( nRUTile, nRULayer, nRUBlock );
132. SetTileAttribute( nLUTile, nLULayer, nLUBlock );_SORT_LAYER:
133. SortLayerTile( nLDTile );
134. SortLayerTile( nRDTile );
135. SortLayerTile( nRUTile );
136. SortLayerTile( nLUTile );
137. } // -------------&-------------
138.  // ---------------------------&------------------------- 
139.  s32 AdjustTileLayer( s32 nTile, s32 nIndex )
140.   {
141. BOOL bCheck  =  FALSE, bFindLayer  =  FALSE;
142. s32 i, nMinLayer, nRetLayer  =   0 ;
143.  for ( i  =   0 ; i  <  TE_LAYERS;  ++ i )
144.   {
145.       if ( m_pTile[nTile].Texture[i]  ==  TE_INVALID_TILE )
146.        {
147.       bCheck  =  TRUE;
148.       m_pTile[nTile].Texture[i]  =  m_nSelectTexture;
149.        if ( m_nSelectTexture  ==   0  )
150.        m_pTile[nTile].Block[i]  =   27 ;
151.        break ;
152.      } 
153. } 
154.  if (  ! bCheck )
155.   {
156.      nMinLayer  =   0 ;      for ( i  =   0 ; i  <  TE_LAYERS;  ++ i )
157.        {
158.        if ( m_pTile[nTile].Texture[i]  ==  m_nSelectTexture )
159.         {
160.        bFindLayer  =  TRUE;
161.        m_pTile[nTile].Texture[i]  =  m_nSelectTexture;
162.         break ;
163.       } 
164.      } 
165.       if (  ! bFindLayer )
166.        {
167.        for ( i  =   0 ; i  <  TE_LAYERS  -   1 ;  ++ i )
168.         {
169.        m_pTile[nTile].Texture[i]  =  m_pTile[nTile].Texture[i + 1 ];
170.        m_pTile[nTile].Block[i]  =  m_pTile[nTile].Block[i + 1 ];
171.       }      
172.             for ( i  =   0 ; i  <  TE_LAYERS  -   1 ;  ++ i )
173.         {
174.         if ( m_pTile[nTile].Texture[i]  ==  m_nSelectTexture )
175.          {
176.         m_pTile[nTile].Texture[TE_LAYERS - 1 ]  =   0 ;
177.         m_pTile[nTile].Block[TE_LAYERS - 1 ]  =  s_pRandTexIndex_c[rand() % TE_TEX_RAND_C];         goto  _SPECIAL_LAYER;
178.        } 
179.       }       m_pTile[nTile].Texture[TE_LAYERS - 1 ]  =  m_nSelectTexture;
180.       m_pTile[nTile].Block[TE_LAYERS - 1 ]  =   0 ;
181.      } 
182. } _SPECIAL_LAYER:
183.  //  for( i = 0; i < TE_LAYERS; ++i )
184.  //  {
185.  //      if( m_pTile[nTile].Texture[i] < m_pTile[nTile].Texture[nMinLayer] )
186.  //      {
187.  //       nMinLayer = i;
188.  //      }
189.  //  }for( i = 0; i < TE_LAYERS; ++i ) 
190.    {
191.       if ( m_pTile[nTile].Texture[i]  ==  m_nSelectTexture )
192.        {
193.       nRetLayer  =  i;
194.        goto  _LAYER_RETURN;
195.      } 
196. } 
197.  for ( i  =   0 ; i  <  TE_LAYERS;  ++ i )
198.   {
199.       if ( m_pTile[nTile].Texture[i]  ==  TE_INVALID_TILE )
200.        {
201.       nRetLayer  =  i;
202.        goto  _LAYER_RETURN;
203.      } 
204. } nRetLayer  =  TE_LAYERS  -   1 ;_LAYER_RETURN: return  nRetLayer;
205. } // +-------------&-------------
206.  // +---------------------------&------------------------- 
207.  void  SortLayerTile( s32 nTile )
208.   {
209. BOOL bBaseLayer  =  FALSE;
210. s32 nBaseLayer  =   - 1 ;
211. s32 i, j, nTex, nBlock; for ( i  =   0 ; i  <  TE_LAYERS;  ++ i )
212.   {
213.       for ( j  =  i  +   1 ; j  <  TE_LAYERS;  ++ j )
214.        {
215.        if ( m_pTile[nTile].Texture[i]  >  m_pTile[nTile].Texture[j] )
216.         {
217.        nTex  =  m_pTile[nTile].Texture[i];
218.        nBlock  =  m_pTile[nTile].Block[i];       m_pTile[nTile].Texture[i]  =  m_pTile[nTile].Texture[j];
219.        m_pTile[nTile].Block[i]  =  m_pTile[nTile].Block[j];       m_pTile[nTile].Texture[j]  =  nTex;
220.        m_pTile[nTile].Block[j]  =  nBlock;
221.       }      } 
222. } nBlock  =   0 ;
223.  for ( i  =   0 ; i  <  TE_LAYERS;  ++ i )
224.   {
225.       if (  ! IsValidRandBlock( m_pTile[nTile].Block[i] ) )
226.        {
227.       nBlock  +=  m_pTile[nTile].Block[i];
228.      } 
229. } if ( nBlock  ==   27  )
230.   {
231.       if ( m_pTile[nTile].Texture[ 0 ]  ==   0  )
232.        {
233.       m_pTile[nTile].Texture[ 0 ]  =  m_pTile[nTile].Texture[ 1 ];
234.       m_pTile[nTile].Block[ 0 ]  =   27 ;       for ( i  =   1 ; i  <  TE_LAYERS  -   1 ;  ++ i )
235.         {
236.        m_pTile[nTile].Texture[i]  =  m_pTile[nTile].Texture[i + 1 ];
237.        m_pTile[nTile].Block[i]  =  m_pTile[nTile].Block[i + 1 ];
238.       }       m_pTile[nTile].Texture[TE_LAYERS - 1 ]  =  TE_INVALID_TILE;
239.       m_pTile[nTile].Block[TE_LAYERS - 1 ]  =   0 ;
240.      } 
241.       else 
242.         {
243.       m_pTile[nTile].Block[ 0 ]  =   27 ;
244.      } 
245. } 
246. } // -------------&-------------
247.  // ---------------------------&------------------------- 
248.  BOOL IsValidTileBlock( s32 nBlock )  const 
249.    {
250. s32 i  =   0 ; if ( nBlock  ==   0   ||  nBlock  ==   27  )
251.       return  TRUE; for ( ; i  <  TE_TEX_RAND_C;  ++ i )
252.   {
253.       if ( nBlock  ==  s_pRandTexIndex_c[i] )
254.        return  FALSE;
255. } return  TRUE;
256. } // -------------&-------------
257.  // ---------------------------&------------------------- 
258.  BOOL IsValidRandBlock( s32 nBlock )  const 
259.    {
260. s32 i  =   0 ;
261.  for ( ; i  <  TE_TEX_RAND_C;  ++ i )
262.   {
263.       if ( nBlock  ==  s_pRandTexIndex_c[i] )
264.        return  TRUE;
265. } return  FALSE;
266. } // +-------------&-------------
267.  // +---------------------------&------------------------- 
268.  s32 CheckLayerTile( s32 nTile, s32 nTexture )
269.   {
270. s32 i; for ( i  =   0 ; i  <  TE_TILE_COUNT;  ++ i )
271.   {
272.       if ( m_pTile[nTile].Texture[i]  !=  TE_INVALID_TILE  &&  m_pTile[nTile].Texture[i]  ==  nTexture )
273.        return  i;
274. } return   - 1 ;
275. } // +-------------&-------------
276.  // +---------------------------&------------------------- 
277.  void  UpdateTileAttribute( s32 nLDTile, s32 nRDTile, s32 nRUTile, s32 nLUTile )
278.   {
279. s32 i, nBlock, nLDTexture;
280. s32 nLDLayer, nRDLayer, nRULayer, nLULayer; if ( IsValidRandBlock(m_pTile[nLDTile].Block[ 0 ])  &&  m_pTile[nLDTile].Texture[ 0 ]  !=   0  )
281.   {
282.      nBlock  =   27 ;
283.       for ( i  =   1 ; i  <  TE_LAYERS;  ++ i )
284.        {
285.        if ( m_pTile[nLDTile].Texture[i]  !=  TE_INVALID_TILE )
286.         {
287.        nBlock  -=  m_pTile[nLDTile].Block[i];
288.       } 
289.      }      m_pTile[nLDTile].Block[ 0 ]  =  nBlock;
290. } if ( IsValidRandBlock(m_pTile[nRDTile].Block[ 0 ])  &&  m_pTile[nRDTile].Texture[ 0 ]  !=   0  )
291.   {
292.      nBlock  =   27 ;
293.       for ( i  =   1 ; i  <  TE_LAYERS;  ++ i )
294.        {
295.        if ( m_pTile[nRDTile].Texture[i]  !=  TE_INVALID_TILE )
296.         {
297.        nBlock  -=  m_pTile[nRDTile].Block[i];
298.       } 
299.      }      m_pTile[nRDTile].Block[ 0 ]  =  nBlock;
300. } if ( IsValidRandBlock(m_pTile[nRUTile].Block[ 0 ])  &&  m_pTile[nRUTile].Texture[ 0 ]  !=   0  )
301.   {
302.      nBlock  =   27 ;
303.       for ( i  =   1 ; i  <  TE_LAYERS;  ++ i )
304.        {
305.        if ( m_pTile[nRUTile].Texture[i]  !=  TE_INVALID_TILE )
306.         {
307.        nBlock  -=  m_pTile[nRUTile].Block[i];
308.       } 
309.      }      m_pTile[nRUTile].Block[ 0 ]  =  nBlock;
310. } if ( IsValidRandBlock(m_pTile[nLUTile].Block[ 0 ])  &&  m_pTile[nLUTile].Texture[ 0 ]  !=   0  )
311.   {
312.      nBlock  =   27 ;
313.       for ( i  =   1 ; i  <  TE_LAYERS;  ++ i )
314.        {
315.        if ( m_pTile[nLUTile].Texture[i]  !=  TE_INVALID_TILE )
316.         {
317.        nBlock  -=  m_pTile[nLUTile].Block[i];
318.       } 
319.      }      m_pTile[nLUTile].Block[ 0 ]  =  nBlock;
320. } //  找出对应的层 
321.  for ( i  =   0 ; i  <  TE_TILE_COUNT;  ++ i )
322.   {
323.      nLDLayer  =  i;
324.      nLDTexture  =  m_pTile[nLDTile].Texture[i];      if ( nLDTexture  ==  m_nSelectTexture )
325.        continue ;     nRDLayer  =  CheckLayerTile( nRDTile, nLDTexture );
326.       if ( nRDLayer  ==   - 1  )
327.        continue ;     nRULayer  =  CheckLayerTile( nRUTile, nLDTexture );
328.       if ( nRULayer  ==   - 1  )
329.        continue ;     nLULayer  =  CheckLayerTile( nLUTile, nLDTexture );
330.       if ( nLULayer  ==   - 1  )
331.        continue ;      if ( IsValidRandBlock( m_pTile[nLDTile].Block[nLDLayer] )  && 
332.          IsValidRandBlock( m_pTile[nRDTile].Block[nRDLayer] )  &&  
333.          IsValidRandBlock( m_pTile[nRUTile].Block[nRULayer] )  &&  
334.          IsValidRandBlock( m_pTile[nLUTile].Block[nLULayer] ) )
335.        {
336.        if ( m_nSelectTexture  <  nLDTexture )
337.         {
338.        m_pTile[nLDTile].Block[nLDLayer]  =   27   -  s_pBaseTexIndex_c[ 2 ];
339.        m_pTile[nRDTile].Block[nRDLayer]  =   27   -  s_pBaseTexIndex_c[ 3 ];
340.        m_pTile[nRUTile].Block[nRULayer]  =   27   -  s_pBaseTexIndex_c[ 1 ];
341.        m_pTile[nLUTile].Block[nLULayer]  =   27   -  s_pBaseTexIndex_c[ 0 ];
342.       } 
343.        continue ;
344.      }       if (  ! IsValidSubBlock( nLDTile, nLDLayer,  2  )  ||  
345.           ! IsValidSubBlock( nRDTile, nRDLayer,  3  )  ||  
346.           ! IsValidSubBlock( nRUTile, nRULayer,  1  )  ||  
347.           ! IsValidSubBlock( nLUTile, nLULayer,  0  ) )
348.        {
349.        continue ;
350.      }      ChangeBlock( nLDTile, nLDLayer,  2  );
351.      ChangeBlock( nRDTile, nRDLayer,  3  );
352.      ChangeBlock( nRUTile, nRULayer,  1  );
353.      ChangeBlock( nLUTile, nLULayer,  0  );
354. } 
355. } // +-------------&-------------
356.  // +---------------------------&------------------------- 
357.  BOOL IsValidSubBlock( s32 nTile, s32 nLayer, s32 nIndex )
358.   {
359. s32 nBlock  =  m_pTile[nTile].Block[nLayer]  -  s_pBaseTexIndex_c[nIndex]; if (  ! IsValidBlock( nBlock ) )
360.       return  FALSE; if ( nBlock  ==   0   ||   ! IsValidRandBlock( nBlock ) )
361.       return  TRUE; return  TRUE;
362. } // +-------------&-------------
363.  // +---------------------------&------------------------- 
364.  void  ChangeBlock( s32 nTile, s32 nLayer, s32 nIndex )
365.   {
366. s32 nBlock  =  m_pTile[nTile].Block[nLayer]; if (  ! IsValidRandBlock( nBlock ) )
367.   {
368.      nBlock  =  nBlock  -  s_pBaseTexIndex_c[nIndex];
369.      m_pTile[nTile].Block[nLayer]  =  nBlock;      if ( nBlock  ==   0  )
370.        {
371.       m_pTile[nTile].Block[nLayer]  =   0 ;
372.       m_pTile[nTile].Texture[nLayer]  =  TE_INVALID_TILE;
373.      } 
374. } 
375.  else 
376.    {
377.      m_pTile[nTile].Block[nLayer]  =   27   -  s_pBaseTexIndex_c[nIndex];
378. } 
379. } // -------------&-------------
380.  // ---------------------------&------------------------- 
381.  void  SetTileAttribute( s32 nTile, s32 nLayer, s32 nBlock )
382.   {
383.  if ( nBlock  ==   27  )
384.   {
385.       //  nBlock = s_pRandTexIndex_c[rand() % TE_TEX_RAND_C];     s32 i = 0; 
386.        for ( ; i  <  TE_TILE_COUNT;  ++ i )
387.        {
388.        if ( m_pTile[nTile].Texture[i]  <  m_nSelectTexture )
389.         {
390.        m_pTile[nTile].Block[i]  =   0 ;
391.        m_pTile[nTile].Texture[i]  =  TE_INVALID_TILE;
392.       } 
393.      }      m_pTile[nTile].Texture[nLayer]  =  m_nSelectTexture;
394. } if (  ! IsValidBlock( nBlock ) )
395.   {
396.      nBlock  =   0 ;
397. } if ( nBlock  >=   32  )
398.   {
399.      nBlock  =   27 ;
400. } m_pTile[nTile].Block[nLayer]  =  nBlock;
401. }