root/lang/d/koke/trunk/map.d @ 6347

Revision 6347, 8.8 kB (checked in by itkz, 6 years ago)

update to 7

Line 
1/********************************************************************************/
2/*      map.d                                                                                                                                           */
3/*------------------------------------------------------------------------------*/
4/*      製作              ( ゜ワ゜)ノ / 松久貫太                                                                  */
5/*      製作開始    2008/01/03                                                                                                              */
6/*      MAIL            omega@personal.email.ne.jp                                                                              */
7/*      URL             http://nagoya.cool.ne.jp/o_mega                                                                         */
8/*                                                                                                                                                              */
9/*      このソースは「やわらかライセンス」の元で配布されています。                                   */
10/*-更新履歴---------------------------------------------------------------------*/
11/*      2008/01/04                                                                                                                                      */
12/*-その他-----------------------------------------------------------------------*/
13/*      なし                                                                                                                                              */
14/********************************************************************************/
15
16private import gamecore;
17private import hell2;
18private import boot;
19private import actor;
20private import vector;
21private import keypad;
22
23private import character;
24
25
26//********************************************************************************
27// マップちっぷ
28//********************************************************************************
29
30const static int CHIP_SIZE = 32;
31
32class MapChip{
33        enum TYPE{
34                NONE = 0,
35                CURSOR = 0,
36                MOVIE = 1,
37                FENCE,
38        }
39        const static string name[] = ["NONE" , "MOVIE" , "FENCE"];
40       
41        const static int TYPEDRAW_LOOP = 16;
42        static int GRASS_COLOR_R = 128;
43        static int GRASS_COLOR_G = 128;
44        static int GRASS_COLOR_B = 128;
45       
46       
47        double grass;
48       
49        TYPE type;
50       
51        this(){
52                GRASS_COLOR_R = configparser.getint("MAP_GRASS_COLOR_R");
53                GRASS_COLOR_G = configparser.getint("MAP_GRASS_COLOR_G");
54                GRASS_COLOR_B = configparser.getint("MAP_GRASS_COLOR_B");
55               
56                init();
57        }
58       
59        void init(){
60                grass = 0;
61                type = TYPE.NONE;
62        }
63       
64        void drawBase(double x,double y){
65                /* 本来はCHIP_SIZE * CHIP_SIZE分コピーすべきだが、高速化のため下半分だけコピーする */
66                Hell_drawTexture("char" , x , y + CHIP_SIZE / 2
67                        ,0
68                        ,CHIP_SIZE / 2
69                        ,CHIP_SIZE
70                        ,CHIP_SIZE / 2);
71               
72                /* 本来のコード
73                Hell_drawTexture("char" , x , y
74                        ,0
75                        ,0
76                        ,CHIP_SIZE
77                        ,CHIP_SIZE);
78                */
79        }
80        void draw(double x , double y,int anime = 0){
81                if(type == TYPE.NONE){
82                        // 芝
83                        if(getGrassLevel() < 1) return;
84                        Hell_drawTexture("char" , x , y
85                                ,0
86                                ,CHIP_SIZE * getGrassLevel()
87                                ,CHIP_SIZE
88                                ,CHIP_SIZE,1,1,0, GRASS_COLOR_R,GRASS_COLOR_G,GRASS_COLOR_B);
89                }else{
90                        // オブジェクト
91                        Hell_drawTexture("char" , x , y
92                                ,CHIP_SIZE * anime + CHIP_SIZE
93                                ,CHIP_SIZE * (type % TYPEDRAW_LOOP)
94                                ,CHIP_SIZE
95                                ,CHIP_SIZE);
96                }
97        }
98       
99        static void drawCursor(double x,double y,int anime = 0){
100                Hell_drawTexture("char" , x , y ,CHIP_SIZE * anime + CHIP_SIZE ,0
101                        ,CHIP_SIZE
102                        ,CHIP_SIZE);
103        }
104       
105        int getGrassLevel(){
106                if(grass < 10){
107                        return 0;
108                }else if(grass < 20){
109                        return 1;
110                }else if(grass < 40){
111                        return 2;
112                }else if(grass < 80){
113                        return 3;
114                }else{
115                        return 4;
116                }
117        }
118}
119
120//********************************************************************************
121// マップ
122//********************************************************************************
123
124class Map{
125        const static double DRAW_CHIP_W = 12.0;
126        const static double DRAW_CHIP_H = 6.0;
127        const static double MOUSE_OFS_X = 16.0;
128        const static double MOUSE_OFS_Y = 18.0;
129       
130        static double MAP_GRASS_AFFECT = 0.90;
131        static double MAP_GRASS_AFFECT_LIMIT = 0.3;
132       
133        static int MAP_REFRESH_INTERVAL = 10;
134       
135        static double MOVIE_GRASS_FEED = 200;
136       
137        GameMain gamemain;
138        MapChip[] map;
139        bool[] movable_map;
140       
141        int width;
142        int height;
143        int timer;
144       
145        double draw_ofs_x;
146        double draw_ofs_y;
147       
148        this(GameMain gamemain , int width , int height){
149                this.gamemain = gamemain;
150                this.width = width;
151                this.height = height;
152               
153                MAP_GRASS_AFFECT = configparser.getfloat("MAP_GRASS_AFFECT");
154                MAP_REFRESH_INTERVAL = configparser.getint("MAP_REFRESH_INTERVAL");
155                MOVIE_GRASS_FEED = configparser.getfloat("MAP_MOVIE_GRASS_FEED");
156                MAP_GRASS_AFFECT_LIMIT = configparser.getfloat("MAP_GRASS_AFFECT_LIMIT");
157               
158                this.map = new MapChip[width * height];
159                foreach(inout m;map) m = new MapChip();
160               
161                this.movable_map = new bool[width * height];
162                foreach(inout mm;movable_map) mm = true;
163               
164                this.draw_ofs_x = 0;
165                this.draw_ofs_y = 0;
166               
167                timer = 0;
168        }
169       
170        void update(){
171                timer++;
172               
173                int[] vecx = [ -1 ,  0 ,  1 ,  0 ];
174                int[] vecy = [  0 , -1 ,  0 ,  1 ];
175               
176                for(int x = 0;x < width;x++){
177                        // 適当に負荷分散してみる
178                        if(timer % MAP_REFRESH_INTERVAL != x % MAP_REFRESH_INTERVAL) continue;
179                       
180                        for(int y=0;y < height;y++){
181                                MapChip here = toMap(x,y);
182                                if(isMap(x,y, MapChip.TYPE.NONE)){
183                                        // 何もない場合は隣接マスから芝えねるぎーを算出する
184                                        int grass_density = 0;
185                                       
186                                        // 周りの芝濃度を算出する
187                                        for(int v=0;v < vecx.length ; v++){
188                                                int px = x + vecx[v];
189                                                int py = y + vecy[v];
190                                               
191                                                if(inRange(px,py)){
192                                                        MapChip m = toMap(px,py);
193                                                        grass_density += m.grass;
194                                                }
195                                        }
196                                        // 濃度にあわせようとする
197                                        grass_density /= vecx.length;//grass_cnt;
198                                       
199                                        if(here.grass < grass_density){
200                                                double a = grass_density - here.grass;
201                                                if(a > MAP_GRASS_AFFECT_LIMIT) a = MAP_GRASS_AFFECT_LIMIT;
202                                                here.grass += a;
203                                        }                               
204                                }else if(isMap(x,y, MapChip.TYPE.MOVIE)){
205                                        // 動画がある場合は無条件に濃度上昇
206                                        here.grass = MOVIE_GRASS_FEED;
207                                }
208                        }
209                }
210               
211                updateMovableMap();
212        }
213       
214        // キャラクタ判定用・移動可能マップを更新する
215        void updateMovableMap(){
216                for(int x = 0;x < width;x++){
217                        for(int y=0;y < height;y++){
218                                bool res = true;
219                               
220                                if(map[x + y * width].type != MapChip.TYPE.NONE) res = false;
221                               
222                                movable_map[x + y * width] = res;
223                        }
224                }
225               
226                CharacterPool cp = gamemain.charpool;
227                foreach(c;cp.actors){
228                        if(c.exist){
229                                Vec3 p = c.getPosition();
230                                if(inRange(cast(int)p.x , cast(int)p.y) && c.isBlocking())
231                                        movable_map[cast(int)p.x + cast(int)p.y * width] = false;
232                        }
233                }
234        }
235       
236        // 作画
237        // 参照・キャラクタバケットソート
238        void draw(){
239                // Map座標系で作画範囲をクリップ
240                int x_st = toRoundMapX(toMapX(0,0));
241                int y_st = toRoundMapY(toMapY(gamemain.getScreenWidth(),0));
242                int x_ed = toRoundMapX(toMapX(gamemain.getScreenWidth() , gamemain.getScreenHeight()) + 2);
243                int y_ed = toRoundMapY(toMapY(0 , gamemain.getScreenHeight()) + 2);
244               
245                for(int x = x_st;x < x_ed;x++){
246                        for(int y = y_st;y < y_ed;y++){
247                                double dx = toViewX(x,y);
248                                double dy = toViewY(x,y);
249                               
250                                if(dx < -32 || dy < -32 || dx > gamemain.getScreenWidth() + 32
251                                        || dy > gamemain.getScreenHeight() + 32) continue;
252                               
253                                toMap(x,y).drawBase(dx , dy);
254                                if(isMap(x,y, MapChip.TYPE.NONE)) toMap(x,y).draw(dx , dy , (timer / 5) % 4);
255                        }
256                }
257               
258                for(int x = x_st;x < x_ed;x++){
259                        for(int y = y_st;y < y_ed;y++){
260                                double dx = toViewX(x,y);
261                                double dy = toViewY(x,y);
262                               
263                                if(dx < -32 || dy < -32 || dx > gamemain.getScreenWidth() + 32
264                                        || dy > gamemain.getScreenHeight() + 32) continue;
265                               
266                                if(!isMap(x,y, MapChip.TYPE.NONE)) toMap(x,y).draw(dx , dy , (timer / 5) % 4);
267                                gamemain.charpool.drawAtMap(x,y);
268                        }
269                }
270        }
271       
272        bool set(int x,int y,MapChip.TYPE type){
273                if(!inRange(x,y)) return false;
274               
275                MapChip m = toMap(x,y);
276                m.type = type;
277                m.grass = 0;
278                return true;
279        }
280       
281        // 芝刈
282        bool setGrass(int x,int y,double grass){
283                if(!inRange(x,y)) return false;
284               
285                MapChip m = toMap(x,y);
286                m.grass = grass;
287                return true;
288        }
289       
290        double getGrass(int x,int y){
291                if(!inRange(x,y)) return 0;
292               
293                MapChip m = toMap(x,y);
294                return m.grass;
295        }
296       
297        int getGrassLevel(int x,int y){
298                if(!inRange(x,y)) return 0;
299               
300                MapChip m = toMap(x,y);
301                return m.getGrassLevel();
302        }
303       
304        bool isMap(int x,int y,MapChip.TYPE type){
305                if(!inRange(x,y)) return false;
306               
307                MapChip m = toMap(x,y);
308                return m.type == type;
309        }
310       
311        // 座標変換
312        double toViewX(double x,double y){return (x - y) * DRAW_CHIP_W + draw_ofs_x;}
313        double toViewY(double x,double y){return (x + y) * DRAW_CHIP_H + draw_ofs_y;}
314        int toMapX(int x,int y){
315                return cast(int)(((x - draw_ofs_x - MOUSE_OFS_X) / DRAW_CHIP_W + (y - draw_ofs_y - MOUSE_OFS_Y) / DRAW_CHIP_H) / 2);
316        }
317        int toMapY(int x,int y){
318                return cast(int)(((y - draw_ofs_y - MOUSE_OFS_Y) / DRAW_CHIP_H - (x - draw_ofs_x - MOUSE_OFS_X) / DRAW_CHIP_W) / 2);
319        }
320       
321        int toRoundMapX(int x){
322                if(x < 0) return 0;
323                if(x >= width) return width;
324                return x;
325        }
326        int toRoundMapY(int y){
327                if(y < 0) return 0;
328                if(y >= height) return height;
329                return y;
330        }
331       
332        bool inRange(int x,int y){
333                return x >= 0 && y >= 0 && x < width && y < height;
334        }
335       
336        MapChip toMap(int x,int y){return map[x + y * width];}
337        bool isMovable(int x,int y){
338                if(inRange(x,y)) return movable_map[x + y * width];
339                return true;    // 欄外は移動可能領域
340        }
341       
342        int count(MapChip.TYPE type){
343                int result = 0;
344                foreach(m;map){
345                        if(m.type == type) result++;
346                }
347                return result;
348        }
349}
350
Note: See TracBrowser for help on using the browser.