合計 昨日 今日

ぷるぷるプログラミング

Name: どぶろく
[URL]
プログラマー(30,434 ポイント)
Date: 2017年11月24日(金) 18:25
No: 1
(OFFLINE)

 ぷるぷるプログラミング

何のことはないプログラムが面白い。

Name: どぶろく
[URL]
プログラマー(30,434 ポイント)
Date: 2017年11月24日(金) 20:32
No: 2
(OFFLINE)

 Re: ぷるぷるプログラミング

コード[C++]: 全て選択
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
#include "DxLib.h"
 
#define  DD_GRAY     85, 85, 85    // 暗い灰色         -1
#define  BLACK        0,  0,  0    // 黒                0
#define  D_RED       28,  0,  0    // 暗い赤            1
#define  D_GREEN      0,128,  0    // 暗い緑            2
#define  D_YELLOW   128,128,  0    // 暗い黄色(深黄色)3
#define  D_BLUE       0,  0,128    // 暗い青            4
#define  D_MAGENTA  128,  0,128    // 暗いマゼンタ      5
#define  D_CYAN       0,128,128    // 暗いシアン        6
 
#define  MD_RED     191, 0,   0    // やや暗い赤             _1
#define  MD_GREEN     0,191,  0    // やや暗い緑             _2
#define  MD_YELLOW  191,191,  0    // やや暗い黄色(黄銅色) _3
#define  MD_BLUE      0,  0,191    // やや暗い青             _4
#define  MD_MAGENTA 191,  0,191    // やや暗いマゼンタ       _5
#define  MD_CYAN      0,191,191    // やや暗いシアン         _6
 
#define  GRAY       192,192,192    // 明るい灰色              7
#define  M_GREEN    192,220,192    // マネーグリーン          8
#define  S_BLUE     166,202,240    // スカイブルー            9
 
#define  CREAM      255,251,240    // クリーム(淡黄色)      246
#define  M_GRAY     160,160,164    // ミディアムグレー        247
#define  D_GRAY     128,128,128    // 暗い灰色                248
#define  RED        255,  0,  0    // 明るい赤                249
#define  GREEN        0,255,  0    // 明るい緑                250
#define  YELLOW     255,255,  0    // 明るい黄色              251
#define  BLUE         0,  0,255    // 明るい青                252
#define  MAGENTA    255,  0,255    // マゼンタ(紫:淡紅色)  253
#define  CYAN         0,255,255    // シアン(水色:輝淡青色)254
#define  WHITE      255,255,255    // 白(最大輝度白色光)    255
 
//------------------------------------------------
#define  KURO        0    // 黒                        0
#define  AKA         1    // 明るい赤                249
#define  MIDORI      2    // 明るい緑                250
#define  KIIRO       3    // 明るい黄色              251
#define  AO          4    // 明るい青                252
#define  MURASAKI    5
#define  MIZUIRO     6
#define  SIRO        7    // 白(最大輝度白色光)    255
#define  D_AKA       8
#define  D_MIDORI    9
#define  D_KIIRO    10
#define  D_AO       11
#define  D_MURASAKI 12
#define  D_MIZUIRO  13
#define  DD_HAIIRO  14
#define  HAIIRO     21
#define  SORAIRO    23
#define  D_HAIIRO   26
 
//-----------------------------------------------------------------------------
// パレットに色をセットする
//-----------------------------------------------------------------------------
void set_pal(int handle)
{
    SetPaletteSoftImage( handle, 0, BLACK, 0 ) ;
    SetPaletteSoftImage( handle, 1, RED, 0 ) ;
    SetPaletteSoftImage( handle, 2, GREEN, 0 ) ;
    SetPaletteSoftImage( handle, 3, YELLOW, 0 ) ;
    SetPaletteSoftImage( handle, 4, BLUE, 0 ) ;
    SetPaletteSoftImage( handle, 5, MAGENTA, 0 ) ;
    SetPaletteSoftImage( handle, 6, CYAN, 0 ) ;
    SetPaletteSoftImage( handle, 7, WHITE, 0 ) ;
 
    SetPaletteSoftImage( handle, 8, D_RED, 0 ) ;
    SetPaletteSoftImage( handle, 9, D_GREEN, 0 ) ;
    SetPaletteSoftImage( handle,10, D_YELLOW, 0 ) ;
    SetPaletteSoftImage( handle,11, D_BLUE, 0 ) ;
    SetPaletteSoftImage( handle,12, D_MAGENTA, 0 ) ;
    SetPaletteSoftImage( handle,13, D_CYAN, 0 ) ;
    SetPaletteSoftImage( handle,14, DD_GRAY, 0 ) ;
 
    SetPaletteSoftImage( handle,15, MD_RED, 0 ) ;
    SetPaletteSoftImage( handle,16, MD_GREEN, 0 ) ;
    SetPaletteSoftImage( handle,17, MD_YELLOW, 0 ) ;
    SetPaletteSoftImage( handle,18, MD_BLUE, 0 ) ;
    SetPaletteSoftImage( handle,19, MD_MAGENTA, 0 ) ;
    SetPaletteSoftImage( handle,20, MD_CYAN, 0 ) ;
 
    SetPaletteSoftImage( handle,21, GRAY, 0 ) ;
    SetPaletteSoftImage( handle,22, M_GREEN, 0 ) ;
    SetPaletteSoftImage( handle,23, S_BLUE, 0 ) ;
    SetPaletteSoftImage( handle,24, CREAM, 0 ) ;
    SetPaletteSoftImage( handle,25, M_GRAY, 0 ) ;
    SetPaletteSoftImage( handle,26, D_GRAY, 0 ) ;
}
 
//-----------------------------------------------------------------------------
// 画像データ
//-----------------------------------------------------------------------------
char img[16][16] ={
    { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
    { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
    { 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 },
    { 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 },
    { 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4 },
    { 5, 5, 5, 7, 1, 5, 5, 5, 7, 1, 5, 5, 5, 7, 2, 5 },
    { 5, 5, 5, 7,10, 5, 5, 5, 7,10, 5, 5, 5, 7,20, 5 },
    { 5, 5, 5, 7,10, 5, 5, 5, 7,10, 5, 5, 5, 7,20, 5 },
    { 5, 5, 5, 7,10, 5, 5, 5, 7,10, 5, 5, 5, 7,20, 5 },
    { 5, 5, 5, 7,10, 5, 5, 5, 7,10, 5, 5, 5, 7,20, 5 },
    { 5, 5, 5, 7,10, 5, 5, 5, 7,10, 5, 5, 5, 7,20, 5 },
    { 5, 5, 5, 7,10, 5, 5, 5, 7,10, 5, 5, 5, 7,20, 5 },
    { 5, 5, 5, 7,10, 5, 5, 5, 7,10, 5, 5, 5, 7,20, 5 },
    { 5, 5, 5, 7,10, 5, 5, 5, 7,10, 5, 5, 5, 7,20, 5 },
    { 5, 5 ,5, 7,10, 5, 5, 5, 7,10, 5, 5, 5, 7,20, 5 },
    { 5, 5, 5, 7,10, 5, 5, 5, 7,10, 5, 5, 5, 7,20, 5 }
};
 
//-----------------------------------------------------------------------------
// エントリポイント
//-----------------------------------------------------------------------------
int WINAPI WinMain( HINSTANCE, HINSTANCE, LPSTR, int )
{
    int handle, i, j, grhandle ;
 
    ChangeWindowMode(TRUE);
    if( DxLib_Init() < 0 ) return -1;
 
    handle = MakePAL8ColorSoftImage( 16, 16 ) ; // 空のパレット画像を作成する
    set_pal(handle);            // パレットに色をセットする
 
    for( j = 0; j < 16; j ++ ){
        for( i = 0; i < 16; i ++ ){
            DrawPixelPalCodeSoftImage( handle, i, j, img[j][i] ) ;  // パレット番号をセット
        }
    }
    grhandle = CreateGraphFromSoftImage( handle ) ;           // グラフィックハンドルを作成
    DeleteSoftImage( handle ) ;    // 使い終わったら解放
 
    DrawExtendGraph( 0, 0, 16*4, 16*4, grhandle, FALSE ) ;    // グラフィックハンドルを描画(四倍に拡大する)
    DeleteGraph( grhandle ) ;      // グラフィックハンドルの削除
 
    WaitKey();      // キー入力待ち
    DxLib_End();    // DXライブラリの後始末
 
    return 0;
}

Name: どぶろく
[URL]
プログラマー(30,434 ポイント)
Date: 2017年11月26日(日) 08:43
No: 3
(OFFLINE)

 Re: ぷるぷるプログラミング

んん、前に書いた記事の編集ができない?!
時間がたつと編集できなくなるのか・・・
まぁ、いけど。
前回は構造体の画像データを表示できたので、今回はキャラ作りです。
つまりドット絵。ぴこぴこ構造体に画像データを打ち込むのがいいのだ、めんどいけど(笑)
それが、ぷるぷるプログラミングなのだ!

Name: どぶろく
[URL]
プログラマー(30,434 ポイント)
Date: 2017年11月26日(日) 14:42
No: 4
(OFFLINE)

 Re: ぷるぷるプログラミング

コード[C++]: 全て選択
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
#include "DxLib.h"
 
#define  DD_GRAY     85, 85, 85    // 暗い灰色         -1
#define  BLACK        0,  0,  0    // 黒                0
#define  D_RED       28,  0,  0    // 暗い赤            1
#define  D_GREEN      0,128,  0    // 暗い緑            2
#define  D_YELLOW   128,128,  0    // 暗い黄色(深黄色)3
#define  D_BLUE       0,  0,128    // 暗い青            4
#define  D_MAGENTA  128,  0,128    // 暗いマゼンタ      5
#define  D_CYAN       0,128,128    // 暗いシアン        6
 
#define  MD_RED     191, 0,   0    // やや暗い赤             _1
#define  MD_GREEN     0,191,  0    // やや暗い緑             _2
#define  MD_YELLOW  191,191,  0    // やや暗い黄色(黄銅色) _3
#define  MD_BLUE      0,  0,191    // やや暗い青             _4
#define  MD_MAGENTA 191,  0,191    // やや暗いマゼンタ       _5
#define  MD_CYAN      0,191,191    // やや暗いシアン         _6
 
#define  GRAY       192,192,192    // 明るい灰色              7
#define  M_GREEN    192,220,192    // マネーグリーン          8
#define  S_BLUE     166,202,240    // スカイブルー            9
 
#define  CREAM      255,251,240    // クリーム(淡黄色)      246
#define  M_GRAY     160,160,164    // ミディアムグレー        247
#define  D_GRAY     128,128,128    // 暗い灰色                248
#define  RED        255,  0,  0    // 明るい赤                249
#define  GREEN        0,255,  0    // 明るい緑                250
#define  YELLOW     255,255,  0    // 明るい黄色              251
#define  BLUE         0,  0,255    // 明るい青                252
#define  MAGENTA    255,  0,255    // マゼンタ(紫:淡紅色)  253
#define  CYAN         0,255,255    // シアン(水色:輝淡青色)254
#define  WHITE      255,255,255    // 白(最大輝度白色光)    255
#define  LD_CYAN      0,150,255    // 少しだけ暗いシアン
 
//-----------------------------------------------------------------------------
// パレットに色をセットする
//-----------------------------------------------------------------------------
void set_pal(int handle)
{
    SetPaletteSoftImage( handle, 0, BLACK, 0 ) ;
    SetPaletteSoftImage( handle, 1, WHITE, 0 ) ;
    SetPaletteSoftImage( handle, 2, RED, 0 ) ;
    SetPaletteSoftImage( handle, 3, D_YELLOW, 0 ) ;
    SetPaletteSoftImage( handle, 4, D_GREEN, 0 ) ;
    SetPaletteSoftImage( handle, 5, LD_CYAN, 0 ) ;
    SetPaletteSoftImage( handle, 6, YELLOW, 0 ) ;
    SetPaletteSoftImage( handle, 7, CYAN, 0 ) ;
 
}
 
//-----------------------------------------------------------------------------
// 画像データ
//-----------------------------------------------------------------------------
char img[32][32] ={
    { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    { 0,0,0,0,0,0,0,0,0,0,0,5,5,5,5,6,5,5,5,5,0,0,0,0,0,0,0,0,0,0,0,0},
    { 0,0,0,0,0,0,0,0,0,0,0,5,5,5,5,6,5,5,5,5,0,0,0,0,0,0,0,0,0,0,0,0},
    { 0,0,0,0,0,2,2,2,2,0,5,5,7,5,5,6,5,5,7,5,5,0,0,2,2,2,2,0,0,0,0,0},
    { 0,0,0,7,7,7,7,4,7,7,0,5,5,5,5,6,5,5,5,5,0,0,7,7,4,7,7,7,7,7,0,0},
    { 0,0,0,7,7,7,7,4,7,7,0,5,5,5,5,6,5,5,5,5,0,0,7,7,4,7,7,7,7,7,0,0},
    { 0,0,7,7,7,7,7,4,7,7,7,7,7,6,6,6,6,6,6,7,7,7,7,7,4,7,7,7,7,7,7,0},
    { 0,0,7,7,7,7,7,4,7,7,7,7,7,6,6,6,6,6,6,7,7,7,7,7,4,7,7,7,7,7,7,0},
    { 0,7,7,7,7,7,7,4,4,4,4,4,4,4,6,6,6,6,4,4,4,4,4,4,4,7,7,7,7,7,7,7},
    { 0,7,7,7,7,7,7,4,4,4,4,4,4,4,6,6,6,6,4,4,4,4,4,4,4,7,7,7,7,7,7,7},
    { 0,7,7,7,7,7,7,7,7,7,7,7,7,7,6,6,6,6,7,7,7,7,7,7,7,7,7,7,7,7,7,7},
    { 0,7,7,7,7,7,7,7,7,7,7,7,7,7,6,6,6,6,7,7,7,7,7,7,7,7,7,7,7,7,7,7},
    { 0,0,7,4,4,4,4,4,4,4,4,4,4,4,6,6,6,6,4,4,4,4,4,4,4,4,4,4,7,7,0,0},
    { 0,0,7,4,4,4,4,4,4,4,4,4,4,4,6,6,6,6,4,4,4,4,4,4,4,4,4,4,7,7,0,0},
    { 0,0,0,4,0,4,4,4,4,4,4,4,4,4,6,6,6,6,4,4,4,4,4,4,4,4,0,4,0,0,0,0},
    { 0,0,0,4,0,4,4,4,4,4,4,4,4,4,6,6,6,6,4,4,4,4,4,4,4,4,0,4,0,0,0,0},
    { 0,0,0,4,0,4,0,0,0,0,0,6,6,6,6,6,6,6,6,6,6,0,0,0,0,4,0,4,0,0,0,0},
    { 0,0,0,4,0,4,0,0,0,0,0,6,6,6,6,6,6,6,6,6,6,0,0,0,0,4,0,4,0,0,0,0},
    { 0,0,0,4,0,4,0,0,0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,0,0,4,0,4,0,0,0,0},
    { 0,0,0,4,0,4,0,0,0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,0,0,4,0,4,0,0,0,0},
    { 0,2,2,2,0,4,0,0,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,0,4,0,2,2,2,0,0},
    { 0,2,2,2,0,4,0,0,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,0,4,0,2,2,2,0,0},
    { 0,0,0,0,0,4,0,0,0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,0,0,4,0,0,0,0,0,0},
    { 0,0,0,0,0,4,0,0,0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,0,0,4,0,0,0,0,0,0},
    { 0,0,2,2,2,2,0,0,0,0,6,6,6,6,6,6,6,6,6,6,6,6,0,0,0,2,2,2,2,0,0,0},
    { 0,0,2,2,2,2,0,0,0,0,6,6,6,6,6,6,6,6,6,6,6,6,0,0,0,2,2,2,2,0,0,0},
    { 0,0,0,0,0,0,0,0,0,0,0,3,3,3,3,3,3,3,3,3,3,0,0,0,0,0,0,0,0,0,0,0},
    { 0,0,0,0,0,0,0,0,0,0,0,3,3,3,3,3,3,3,3,3,3,0,0,0,0,0,0,0,0,0,0,0},
    { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,6,6,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
    { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,6,6,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
};
 
//-----------------------------------------------------------------------------
// エントリーポイント
//-----------------------------------------------------------------------------
int WINAPI WinMain( HINSTANCE, HINSTANCE, LPSTR, int )
{
    int handle, i, j, grhandle ;
 
    ChangeWindowMode(TRUE);
    if( DxLib_Init() < 0 ) return -1;
 
    handle = MakePAL8ColorSoftImage( 32, 32 ) ; // 空のパレット画像を作成する
    set_pal(handle);            // パレットに色をセットする
 
    //ドット絵を描く
    for( j = 0; j < 32; j ++ ){
        for( i = 0; i < 32; i ++ ){
            DrawPixelPalCodeSoftImage( handle, i, j, img[j][i] ) ;
        }
    }
    grhandle = CreateGraphFromSoftImage( handle ) ;           // グラフィックハンドルを作成
    DeleteSoftImage( handle ) ;    // 使い終わったら解放
 
    int x=0, y=100;
    DrawExtendGraph( x, y, x+30*4, y+32*4, grhandle, FALSE ) ;    // 描画(4倍に拡大する)
 
    x=100, y=0;
    DrawExtendGraph( x, y, x+30*4, y+32*4, grhandle, FALSE ) ;    // 描画(4倍に拡大する)
   
    x=200; y=200;
    DrawExtendGraph( x, y, x+30*4, y+32*4, grhandle, FALSE ) ;    // 描画(4倍に拡大する)
   
    DrawString(300, 100, "ぶんぶんぶんハチが飛ぶ", GetColor(WHITE));
 
    DrawString(220, 100, "))", GetColor(WHITE));
    DrawString(120, 200, "))", GetColor(WHITE));
    DrawString(320, 300, "))", GetColor(WHITE));
 
    DeleteGraph( grhandle ) ;      // グラフィックハンドルの削除
 
    WaitKey();      // キー入力待ち
    DxLib_End();    // DXライブラリの後始末
 
    return 0;
}

Name: どぶろく
[URL]
プログラマー(30,434 ポイント)
Date: 2017年12月02日(土) 19:58
No: 5
(OFFLINE)

 Re: ぷるぷるプログラミング

前回は、画像データを数字で書いたけど、
見にくい!読みにくい!ので、
アルファベット1文字に置き換えてみました。
格段に見やすくなったぜ!!やったね!!


コード[C++]: 全て選択
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
#include "DxLib.h"
 
#define  DD_GRAY     85, 85, 85    // 暗い灰色         -1
#define  BLACK        0,  0,  0    // 黒                0
#define  D_RED       28,  0,  0    // 暗い赤            1
#define  D_GREEN      0,128,  0    // 暗い緑            2
#define  D_YELLOW   128,128,  0    // 暗い黄色(深黄色)3
#define  D_BLUE       0,  0,128    // 暗い青            4
#define  D_MAGENTA  128,  0,128    // 暗いマゼンタ      5
#define  D_CYAN       0,128,128    // 暗いシアン        6
 
#define  MD_RED     191,  0,  0    // やや暗い赤             _1
#define  MD_GREEN     0,191,  0    // やや暗い緑             _2
#define  MD_YELLOW  191,191,  0    // やや暗い黄色(黄銅色) _3
#define  MD_BLUE      0,  0,191    // やや暗い青             _4
#define  MD_MAGENTA 191,  0,191    // やや暗いマゼンタ       _5
#define  MD_CYAN      0,191,191    // やや暗いシアン         _6
 
#define  GRAY       192,192,192    // 明るい灰色              7
#define  M_GREEN    192,220,192    // マネーグリーン          8
#define  S_BLUE     166,202,240    // スカイブルー            9
 
#define  CREAM      255,251,240    // クリーム(淡黄色)      246
#define  M_GRAY     160,160,164    // ミディアムグレー        247
#define  D_GRAY     128,128,128    // 暗い灰色                248
#define  RED        255,  0,  0    // 明るい赤                249
#define  GREEN        0,255,  0    // 明るい緑                250
#define  YELLOW     255,255,  0    // 明るい黄色              251
#define  BLUE         0,  0,255    // 明るい青                252
#define  MAGENTA    255,  0,255    // マゼンタ(紫:淡紅色)  253
#define  CYAN         0,255,255    // シアン(水色:輝淡青色)254
#define  WHITE      255,255,255    // 白(最大輝度白色光)    255
#define  L_BLUE       0,150,255    // ライトブルー
 
//-----------------------------------------------------------------------------
// パレットに色をセットする
//-----------------------------------------------------------------------------
void set_pal(int handle)
{
    SetPaletteSoftImage( handle, 0, BLACK, 0 ) ;
    SetPaletteSoftImage( handle, 1, WHITE, 0 ) ;
    SetPaletteSoftImage( handle, 2, RED, 0 ) ;
    SetPaletteSoftImage( handle, 3, D_YELLOW, 0 ) ;
    SetPaletteSoftImage( handle, 4, D_GREEN, 0 ) ;
    SetPaletteSoftImage( handle, 5, L_BLUE, 0 ) ;
    SetPaletteSoftImage( handle, 6, YELLOW, 0 ) ;
    SetPaletteSoftImage( handle, 7, CYAN, 0 ) ;
 
}
 
//-----------------------------------------------------------------------------
// 画像データ
//-----------------------------------------------------------------------------
char img[32][33] ={
    "              b b               ",
    "              b b               ",
    "           bbbbYbbbb            ",
    "           bbbbYbbbb            ",
    "     RRRR bbCbbYbbCbb  RRRR     ",
    "     RRRR bbCbbYbbCbb  RRRR     ",
    "   CCCCgCC bbbbYbbbb  CCgCCCCC  ",
    "   CCCCgCC bbbbYbbbb  CCgCCCCC  ",
    "  CCCCCgCCCCCYYYYYYCCCCCgCCCCCC ",
    "  CCCCCgCCCCCYYYYYYCCCCCgCCCCCC ",
    " CCCCCCgggggggYYYYYggggggCCCCCCC",
    " CCCCCCgggggggYYYYYggggggCCCCCCC",
    " CCCCCCCCCCCCCYYYYCCCCCCCCCCCCCC",
    " CCCCCCCCCCCCCYYYYCCCCCCCCCCCCCC",
    "  CgggggggggggYYYYggggggggggCC  ",
    "  CgggggggggggYYYYggggggggggCC  ",
    "   gggggggggggYYYYgggggggg g    ",
    "   g gggggggggYYYYgggggggg g    ",
    "   g g     YYYYYYYYYY    g g    ",
    "   g g     YYYYYYYYYY    g g    ",
    "   g g   yyyyyyyyyyyyyy  g g    ",
    "   g g   yyyyyyyyyyyyyy  g g    ",
    " RRR g  YYYYYYYYYYYYYYYY g RRR  ",
    " RRR g  YYYYYYYYYYYYYYYY g RRR  ",
    "     g   yyyyyyyyyyyyyy  g      ",
    "     g   yyyyyyyyyyyyyy  g      ",
    "  RRRR    YYYYYYYYYYYY   RRRR   ",
    "  RRRR    YYYYYYYYYYYY   RRRR   ",
    "           yyyyyyyyyy           ",
    "           yyyyyyyyyy           ",
    "              YYYY              ",
    "              YYYY              "
};
 
//-----------------------------------------------------------------------------
// エントリーポイント
//-----------------------------------------------------------------------------
int WINAPI WinMain( HINSTANCE, HINSTANCE, LPSTR, int )
{
    int handle, grhandle ;
    int i, j, x, y, c;
    int color = GetColor(WHITE);
 
    ChangeWindowMode(TRUE);
    if( DxLib_Init() < 0 ) return -1;
 
    handle = MakePAL8ColorSoftImage( 32, 32 ) ; // 空のパレット画像を作成する
    set_pal(handle);            // パレットに色をセットする
 
    //ドット絵を描く
    for( j = 0; j < 32; j ++ ){
        for( i = 0; i < 32; i ++ ){
            if(img[j][i]==' ') c=0;
            if(img[j][i]=='R') c=2;
            if(img[j][i]=='y') c=3;
            if(img[j][i]=='g') c=4;
            if(img[j][i]=='b') c=5;
            if(img[j][i]=='Y') c=6;
            if(img[j][i]=='C') c=7;
           
            DrawPixelPalCodeSoftImage( handle, i, j, c ) ;
        }
    }
    grhandle = CreateGraphFromSoftImage( handle ) ;           // グラフィックハンドルを作成
    DeleteSoftImage( handle ) ;    // 使い終わったら解放
 
    x=150; y=0;
    DrawExtendGraph( x, y, x+32*4, y+32*4, grhandle, FALSE ) ;    // 描画(4倍に拡大する)
   
    x=0; y=100;
    DrawExtendGraph( x, y, x+32*4, y+32*4, grhandle, FALSE ) ;    // 描画(4倍に拡大する)
 
    x=200; y=200;
    DrawExtendGraph( x, y, x+32*4, y+32*4, grhandle, FALSE ) ;    // 描画(4倍に拡大する)
   
    DrawString(350, 150, "ぶんぶんぶんハチが飛ぶ", color);
 
    DrawString(300,  50, "))", color);
    DrawString(150, 150, "))", color);
    DrawString(350, 250, "))", color);
 
    DeleteGraph( grhandle ) ;      // グラフィックハンドルの削除
 
    WaitKey();      // キー入力待ち
    DxLib_End();    // DXライブラリの後始末
 
    return 0;
}

Name: どぶろく
[URL]
プログラマー(30,434 ポイント)
Date: 2017年12月05日(火) 14:13
No: 6
(OFFLINE)

 Re: ぷるぷるプログラミング

懐かしのN88BASICのゲームを移植したよ。
動きもまんまBASICしてるよ。これは笑える。
砲台もカッコいい宇宙飛行機みたいに見えてくる。
ではこの射撃ゲームを楽しんでください。

コード[C++]: 全て選択
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
#include "DxLib.h"
 
#define  WHITE      255,255,255    // 白(最大輝度白色光)    255
#define  RED        255,  0,  0    // 明るい赤                249
#define  YELLOW     255,255,  0    // 明るい黄色              251
 
#define  KARASU     20             // カラスの出現数
 
//-----------------------------------------------------------------------------
// ゲームオーバーの処理
//-----------------------------------------------------------------------------
int owari(int s)
{
    if( s > (KARASU/2)){
        DrawString(15*8, 10*16, "あなたの勝ち!", GetColor(YELLOW));
    }else {
        DrawString(15*8, 10*16, "あなたの負け!", GetColor(RED));
    }
    DrawString(16*8, 12*16, "[ESC] 終了", GetColor(WHITE));
    ScreenFlip();
 
    WaitTimer(1000);                    // 少し待たせる
 
    if(WaitKey()==KEY_INPUT_ESCAPE){    // ESCでゲーム終了
        return 1;
    }
    return 0;                           // ゲーム継続
}
 
//-----------------------------------------------------------------------------
// エントリーポイント
//-----------------------------------------------------------------------------
int WINAPI WinMain( HINSTANCE, HINSTANCE, LPSTR, int )
{
    int  color = GetColor(WHITE);// 文字の色
    int  x=0, y=15;              // x*8,y*16の文字座標
    int  s=0;        // 撃ち落としたカラスの数
    int  n=1;        // カラスの出現数
    int  hit=0;      // 弾が命中した
    int  sw=0;       // 弾の発射
    int  key;        // キー押し下げ
 
    ChangeWindowMode(TRUE);
    if( DxLib_Init() < 0 ) return -1;
    SetDrawScreen( DX_SCREEN_BACK ) ;
 
    while(ProcessMessage() == 0 && ClearDrawScreen() == 0 )
    {
        DrawString(29*8, 15*16, " A ", color);
        DrawString(29*8, 16*16, "MIM", color);
        DrawString( 0*8, 17*16, "-------------------------------------", color);
 
        key = GetJoypadInputState( DX_INPUT_KEY_PAD1 ) ;
 
        if( key & PAD_INPUT_9 )  break; // ESCで終了
        if( key & PAD_INPUT_10 ) sw=1;  // SPACEで弾を発射
 
        if(sw==1){      // 弾を発射
            y--;
            if(y<0){        // 弾が上まで来たら
                if(x==30){  // 当たり判定
                    DrawString(30*8, 0, "X", GetColor(RED));
                    s++; x=40; hit=1;
                }
                sw=0; y=15;
            }
            DrawString(30*8, y*16, "I", color); // 弾を描く
        }
        DrawFormatString(0, 16, color, " %d / %d", s, n ); // 出現数と当った数
       
        if(x>=40){   // カラスが右端まで来たら
            x=0; n++;
        }else {
            x++;
            DrawString(x*8, 0, "W", color);    // 動いてるカラス
        }
        ScreenFlip() ;
 
        if(hit){
            hit=0;
            WaitTimer(100);      // ビープ音のために少し待ってやる
            Beep(700, 800);      // 撃ち落とした時のビープ音を鳴らす
        }else {
            WaitTimer(10);       // ビープ音のために少し待ってやる
            Beep(1300, 60);      // カラスの移動の時のビープ音を鳴らす
        }
        if(n>KARASU){   // カラスが20羽出たら終わり
            if(owari(s)){
                break;  // 終了
            }
            x=0; y=15; s=0; n=1; sw=0;  // ゲームをもう一度やる場合
            WaitTimer(200);             // キー押下げをかわすため少し待つ
        }
    }
    DxLib_End();    // DXライブラリの後始末
 
    return 0;
}

Name: どぶろく
[URL]
プログラマー(30,434 ポイント)
Date: 2017年12月08日(金) 13:30
No: 7
(OFFLINE)

 Re: ぷるぷるプログラミング

おかげさまで大好評!「昔懐かしシリーズ」の、はじまり、はじまり。
またまたN88BASICのゲームを移植しましたよ。
動きもまんまBASICしてるよ。これは笑える。

●内容●
コントロールはカーソルキーで行います(左右のみ)。制限時間は1分で、1つの旗門
をクリアするごとに10点増えます。もし旗門の端にぶつかると、10点減点されます。

●応用●
旗門の幅を広くしたりせまくしたりして、その旗門によって得点を変えたりするともっ
と面白くなります。
また制限時間を変えたりしても楽しめます。
私は旗門をゲートだと勘違いして旗門の真中を通るゲームにしてしまいました。
本来のスキーのように旗門をかわしていくゲームにするのもいいでしょう。(笑)

それでは、このスラロームゲームを楽しんでください。

コード[C++]: 全て選択
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
/*-----------------------------------------------------------------------------
    2017-12-06(水)
 
    スラローム
 
-----------------------------------------------------------------------------*/
#include "DxLib.h"
 
#define  BLACK        0,  0,  0     // 黒                      0
#define  WHITE      255,255,255     // 白(最大輝度白色光)  255
#define  RED        255,  0,  0     // 明るい赤              249
#define  YELLOW     255,255,  0     // 明るい黄色            251
 
#define  TIME       (60)            // 制限時間(60秒)
#define  WAIT       (150)           // ウェイト
 
//-----------------------------------------------------------------------------
// ゲートの構造体
//-----------------------------------------------------------------------------
struct SGate {
    int x;
    int y;
};
 
//-----------------------------------------------------------------------------
// 制限時間を超えたら
//-----------------------------------------------------------------------------
int owari(int& HiScore, int score, int time)
{
    DrawBox(0, 0, 41*8, 16, GetColor(RED), TRUE);
    DrawFormatString(0, 0, GetColor(YELLOW), "HiScore %d  score %d  time %d", HiScore, score, time/1000);
   
    if(HiScore < score){
        HiScore = score;
        DrawBox(13*8, 6*16, 29*8, 9*16, GetColor(RED), TRUE);
        DrawString(14*8, 7*16, "あなたの勝ち!", GetColor(YELLOW));
    }else {
        DrawBox(13*8, 6*16, 29*8, 9*16, GetColor(WHITE), TRUE);
        DrawString(14*8, 7*16, "あなたの負け!", GetColor(BLACK));
    }
    ScreenFlip() ;
    WaitTimer(1000);
 
    if(WaitKey()==KEY_INPUT_ESCAPE){    // ESCでゲーム終了
        return 1;
    }
    return 0;
}
 
//-----------------------------------------------------------------------------
// エントリーポイント
//-----------------------------------------------------------------------------
int WINAPI WinMain( HINSTANCE, HINSTANCE, LPSTR, int )
{
    int a=20;           // 自分の位置(x座標)
    int rol=0;          // ゲートの配列番号
    int score=0;        // スコア
    int HiScore=0;      // ハイスコア
    int key;            // キー押し下げ
    int start, end, time=0;         // 経過時間用
    int color = GetColor(WHITE);    // 文字色
    SGate gate[25];                 // ゲートのx座標とy座標を保存する構造体
 
    memset(gate, 0, sizeof(SGate)*25);  // 0で初期化(こういう使い方だったっけ?)
    ChangeWindowMode(TRUE);
    if( DxLib_Init() < 0 ) return -1;
    SetDrawScreen( DX_SCREEN_BACK ) ;
 
    start = GetNowCount();          // スタート時間を記憶させる
 
    while(!ProcessMessage() && !ClearDrawScreen())
    {
        key = GetJoypadInputState( DX_INPUT_KEY_PAD1 ) ;
 
        if( key & PAD_INPUT_9 )  break;   // ESCで終了
        if( key & PAD_INPUT_LEFT )  a--;  // [←]キー
        if( key & PAD_INPUT_RIGHT ) a++;  // [→]キー
 
        if( a<0 ) a=0;          // 左端にきたら
        if( a>39) a=39;         // 右端にきたら
 
        DrawString(a*8, 10*16, "●", color);
 
        gate[rol].x = GetRand(34);      // 乱数でゲートの表示位置(x座標)を決める
        gate[rol].y = 24;               // y座標は一番下から
 
        for(int i=0; i<25 ; i++)        // 当たり判定と全ゲートを表示
        {
            if(((gate[i].x == a)||(gate[i].x == (a+1))||(gate[i].x+6 == a)||(gate[i].x+6 == (a+1))) && (gate[i].y==10)){
                score-=10;
                Beep(3000, 5);          // ゲートの端に当った時
            }
            else if((gate[i].x < a) && ((gate[i].x+6) > a) && (gate[i].y==10)){
                score+=10;
                Beep(1000, 5);          // ゲートをうまく通過した時
            }
            DrawString(gate[i].x*8, gate[i].y*16, "|====|", color);     // ゲートを表示
            gate[i].y--;                // 表示後ゲートのy座標を1つ上にする。
        }
        DrawBox(0, 0, 41*8, 2*16, GetColor(BLACK), TRUE);
        DrawFormatString(0, 0, color, "HiScore %d  score %d  time %d/%d", HiScore, score, time/1000, TIME);
 
        rol++;
        if(rol>24) rol=0;               // ゲートの配列番号をセットしていくため
 
        end  = GetNowCount();           // プレイ時間を計るため
        time = end-start;               // 経過時間を保存
 
        if(time > TIME*1000){           // タイムオーバーの時
            if(owari(HiScore, score, time)){
                break;                  // ゲーム終了
            }
            start = GetNowCount();      // もう一度ゲームをする場合
            a=20; score=0;
            memset(gate, 0, sizeof(SGate)*25);
        }
        ScreenFlip() ;
        WaitTimer(WAIT);                // ゲーム全体のウェイト
    }
    DxLib_End();    // DXライブラリの後始末
 
    return 0;
}

Name: どぶろく
[URL]
プログラマー(30,434 ポイント)
Date: 2017年12月10日(日) 13:43
No: 8
(OFFLINE)

 Re: ぷるぷるプログラミング

大好評!昔なつかしシリーズ第三弾!
その名も「ただ観てるだけ~~~の綱引き」。
やはりC言語の構文は解りやすい。
そして参考にしているN88-BASICはメッチャ難しい。
記述量は少ないのだが、完全なスパゲッティープログラムじゃん・・・
泣きながら「N88互換BASIC for Windows」に打ち込んで実行してます。
もちろん、原文そのままでは動かないので・・・何とか動くようにする。
それからC言語(C++)に移植する。これが楽しい。

コード[C++]: 全て選択
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
/*-----------------------------------------------------------------------------
 
    2017(H29).12/09(土)
 
    綱引きシミュレーション
 
-----------------------------------------------------------------------------*/
#include "DxLib.h"
 
#define WHITE   255,255,255     // 白(最大輝度白色光)       255
#define BLACK     0,  0,  0     // 黒                      0
#define WAIT    (300)           // 全体のウェイト
#define SCORE   (2)             // この得点で勝ち
 
//-----------------------------------------------------------------------------
// エントリーポイント
//-----------------------------------------------------------------------------
int WINAPI WinMain( HINSTANCE, HINSTANCE, LPSTR, int )
{
    int key;
    int r, x=8, s1=0, s2=0;
    int color = GetColor(WHITE);
 
    ChangeWindowMode(TRUE);
    if( DxLib_Init() < 0 ) return -1;
    SetDrawScreen( DX_SCREEN_BACK ) ;
 
    while(!ProcessMessage() && !ClearDrawScreen())
    {
        key = GetJoypadInputState( DX_INPUT_KEY_PAD1 ) ;
       
        if( key & PAD_INPUT_9 )  break;     // ESCで終了
       
        DrawString(15*8, 1*16, "*-----------*", color);
        DrawString(15*8, 2*16, "|  &  |  $  |", color);
        DrawString(15*8, 3*16, "|-----+-----|", color);
        DrawString(15*8, 4*16, "|     |     |", color);
        DrawString(15*8, 5*16, "*-----------*", color);
        DrawFormatString(15*8, 4*16, color, "   %d  |  %d", s1, s2);
       
        if(GetRand(1)){
            r = 1;
        }else {
            r = -1;
        }
        x=x+r;
        DrawString(x*8, 10*16,"&&&&&&&-----+-----$$$$$$$", color);
        DrawString(0, 11*17, "-------------+-----+-----+-------------", color);
        ScreenFlip();
       
        Beep(3000, 10);Beep(2000, 5);
        WaitTimer(WAIT);
 
        if(x<=1){                       // & の勝ち
            s1++; Beep(1000, 1000); x=8;
        }
        if(x>=15){                      // $ の勝ち
            s2++; Beep(1000, 1000); x=8;
        }
       
        if(s1>=SCORE || s2>=SCORE)      // 2点とった方が勝ち
        {
            DrawBox(16*8, 4*16, 28*8, 5*16, GetColor(BLACK), TRUE);
            DrawFormatString(15*8, 4*16, color, "   %d  |  %d", s1, s2);
            DrawString(16*8, 18*13, "HIT ANY KEY", color);
            DrawString(16*8, 18*15, "ESC:終了", color);
            ScreenFlip();
            if(WaitKey()==KEY_INPUT_ESCAPE){    // ESCでゲーム終了
                break;
            }
            s1=0; s2=0;
        }
    }
    DxLib_End();    // DXライブラリの後始末
   
    return 0;
}

Name: どぶろく
[URL]
プログラマー(30,434 ポイント)
Date: 2017年12月13日(水) 14:08
No: 9
(OFFLINE)

 Re: ぷるぷるプログラミング

では、さっそく、大好評の第4弾、発射~~~~~~~~~~~~~~!!
今回のは互換BASICでは動かせなかった。
本の文章と写真とBASICのソースから推察してみたが分からない・・・
しかたがないので、こうやったらいいんじゃないかプログラムになりました。
けっこう長いプログラムになりました。
でも、なぜかしら操作性が悪いんだよね。
しかしN88-BASICだと思えば楽しい操作性です(笑)

●目的●
左上から右下の出口に向かって、どのくらいの時間で出られるかを計ります。

●内容●
コントロールキーはカーソルキー(上、下、左、右)によって行います。
一定時間ごとに乱数によって爆弾を移動して表示しています。これにぶつからずに出口に向かってください。
3回までなら、ぶつかって爆発しても大丈夫です。

●応用●
ゲーム中に、ある時間ごとに乱数を使って出口を変えても面白いと思います。


コード[C++]: 全て選択
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
/*-----------------------------------------------------------------------------
    2017-12-12(火)
 
    出口はどこだ?
 
-----------------------------------------------------------------------------*/
#include "DxLib.h"
 
#define  BLACK        0,  0,  0     // 黒                      0
#define  WHITE      255,255,255     // 白(最大輝度白色光)  255
#define  RED        255,  0,  0     // 明るい赤              249
#define  YELLOW     255,255,  0     // 明るい黄色            251
#define  GREEN        0,255,  0     // 明るい緑              250
 
#define  WAIT       (120)           // 全体のウェイト
#define  KOSUU      (300)           // 爆弾の個数
#define  KAISUU     (4)             // 爆発3回までOK!
#define  IDOU       (50)            // 爆弾移動個数
#define  WAIT_B     (15)            // 爆弾移動までの時間
 
//-----------------------------------------------------------------------------
// 爆弾の構造体
//-----------------------------------------------------------------------------
struct SBakudan {
    int x;
    int y;
};
 
//-----------------------------------------------------------------------------
// 爆弾を配置する
//-----------------------------------------------------------------------------
void make_bakudan(SBakudan bakudan[])
{
    memset(bakudan, 0, sizeof(SBakudan)*(KOSUU+1));
 
    for(int i=0; i<KOSUU; i++){
    lavel:
        bakudan[i].x = GetRand(37)+2;
        bakudan[i].y = GetRand(20)+2;
        if(bakudan[i].x==3 && bakudan[i].y==2){ // 自分の表示位置には無し
            goto lavel;
        }
    }
}
 
//-----------------------------------------------------------------------------
// 枠の描画
//-----------------------------------------------------------------------------
void make_waku()
{
    int White = GetColor(WHITE);    // 文字色
    int Black = GetColor(BLACK);
    int Yellow= GetColor(YELLOW);
 
    for(int x=0; x<40 ;x++){
        DrawString(x*16,  1*16, "■", White);
        DrawString(x*16, 23*16, "■", White);
    }
    for(int y=1; y<23; y++){
        DrawString(0,     y*16, "■", White);
        DrawString(39*16, y*16, "■", White);
    }
    DrawString(36*16, 23*16, "■", Black);
    DrawString(36*16, 24*16+3, "GOAL", Yellow);
}
 
//-----------------------------------------------------------------------------
// 終わりの処理
//-----------------------------------------------------------------------------
int owari(int win, int &rec, int time1, int e)
{
    int White = GetColor(WHITE);    // 文字色
    int Black = GetColor(BLACK);
    int Red   = GetColor(RED);
    int Yellow= GetColor(YELLOW);
 
    if(win==1 && rec<time1){
        win=2;                  // 時間で負けた
    }
    if(e<1) e=1;
    DrawBox(0, 0, 40*16, 1*16, Black, TRUE);
    DrawFormatString(0, 0, Yellow, "rec %d  time %d  あと %d", rec/100, time1/100, e-1) ;
    DrawBox(9*16, 8*16, 19*16, 15*16, Black, TRUE);
    DrawBox(9*16, 8*16, 19*16, 15*16, Yellow, 0);
    DrawString(11*16, 11*16, "Hit Any Key", White);
    DrawString(11*16, 13*16, "[ESC] 終了", White);
 
    if(win==1){
        DrawString(11*16, 9*16,  "あなたの勝ち", Yellow);
        ScreenFlip() ;
        rec = time1;
        Beep(3000, 100);Beep(1000, 100);Beep(1500, 100);
        Beep(3000, 100);Beep(1000, 100);Beep(1500, 100);
    }
    else if(win==2){
        DrawString(11*16, 9*16,  "時間で負けた", Red);
        Beep(2000, 100);Beep(1000, 100);
        ScreenFlip() ;
    }else {
        DrawString(11*16, 9*16,  "あなたの負け", Red);
        ScreenFlip() ;
    }
    WaitTimer(1000);
    if(WaitKey()==KEY_INPUT_ESCAPE){    // [ESC]で終了
        return 1;
    }
    return 0;
}
 
//-----------------------------------------------------------------------------
// エントリーポイント
//-----------------------------------------------------------------------------
int WINAPI WinMain( HINSTANCE, HINSTANCE, LPSTR, int )
{
    int White = GetColor(WHITE);    // 文字色
    int Green = GetColor(GREEN);
    int Red   = GetColor(RED);
    int Yellow= GetColor(YELLOW);
    int key;                    // キー押し下げ
    int start, end, time1=0;    // 経過時間用
    int x=3, y=1;
    int e=KAISUU;               // 爆発可回数
    int win;                    // 勝ちか?
    int r;                      // ランダム
    int c=0;                    // 時間かせぎ
    int rec=1000*60*3;          // 記録
    int osita=1;                // 押下げしたか
    SBakudan bakudan[KOSUU+1];  // 爆弾の座標の構造体の配列
 
    ChangeWindowMode(TRUE);
    if( DxLib_Init() < 0 ) return -1;
    SetFontThickness(1);                // 文字の太さを1ドットにする
    SetDrawScreen( DX_SCREEN_BACK ) ;
 
    make_bakudan(bakudan);          // 爆弾を配置する
    start = GetNowCount();          // スタート時間を記憶させる
 
    while(!ProcessMessage() && !ClearDrawScreen())
    {
        key = GetJoypadInputState( DX_INPUT_KEY_PAD1 ) ;
 
        if( key & PAD_INPUT_9 )  break;   // ESCで終了
        if( key & PAD_INPUT_LEFT )  {x--;  osita=1;}// [←]キー
        if( key & PAD_INPUT_RIGHT ) {x++;  osita=1;}// [→]キー
        if( key & PAD_INPUT_UP )    {y--;  osita=1;}// [↑]キー
        if( key & PAD_INPUT_DOWN )  {y++;  osita=1;}// [↓]キー
 
        if( x<1 ) x=1;
        if( x>38) x=38;
        if( y<2 ) y=2;
        if( y>22){
            if(x==36) y=23;     // ゴール
            else      y=22;
        }
        make_waku();            // 枠をつくる
 
        c++;
        if(c>WAIT_B){           // 爆弾を移動させるまでの時間かせぎ
            c=0;
            for(int i=0 ; i<IDOU ; i++){    // 爆弾をランダムに移動させる
                r=GetRand(KOSUU);
                bakudan[r].x = GetRand(37)+2;
                bakudan[r].y = GetRand(20)+2;
            }
        }
        for(int i=0; i<KOSUU; i++){         // 爆弾を表示
            DrawString(bakudan[i].x*16, bakudan[i].y*16, "@", Green);
        }
        for(int i=0; i<KOSUU; i++){         // 当たり判定
            if(x==bakudan[i].x && y==bakudan[i].y){
                DrawString(x*16, y*16, "●", Red); // 爆発
                if(osita==1 ){
                    Beep(3000, 100);
                    osita=0; e--;
                }
                if(e<1){            // 爆死して残り無し
                    win=0;
                    goto lavel;
                }
            }
            else {
                DrawString(x*16, y*16, "○", White);
            }
        }
        DrawFormatString(0, 0, Yellow, "rec %d  time %d  あと %d", rec/100, time1/100, e-1) ;
 
        end  = GetNowCount();           // プレイ時間を計るため
        time1 = end-start;              // 経過時間を保存
 
        if(x==36 && y==23){             // ゴールしたら
            win=1;
lavel:
            if(owari(win, rec, time1, e)){
                break;                  // ゲーム終了
            }
            else {                      // もう一度ゲームをする場合
                x=3; y=1; e=KAISUU; osita=1; c=0;
                make_bakudan(bakudan);
                start = GetNowCount();
            }
        }
        ScreenFlip() ;
        WaitTimer(WAIT);                // ゲーム全体のウェイト
    }
    DxLib_End();    // DXライブラリの後始末
 
    return 0;
}

Name: どぶろく
[URL]
プログラマー(30,434 ポイント)
Date: 2017年12月18日(月) 18:28
No: 10
(OFFLINE)

 Re: ぷるぷるプログラミング

あら、まあ、大好評の第5弾、いくよ~~~~~~!!

●内容●
出走馬数(1~12)を入力します。入力した数だけ馬の構造体をnewで確保してます。
一斉に走り出します。文字幅の8ドット単位ではなく微妙な差がつくんではないかな、
と。いう思惑で、1~21ドット単位の移動にしました。

●応用●
コースの設定を右端まで行ったら向きをかえて戻ってくるようにしたり、
また落馬などの処理を追加すると面白くなるでしょう。

コード[C++]: 全て選択
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
//-----------------------------------------------------------------------------
// 2017-12-17(日)
//
// 競馬ゲーム
//
//-----------------------------------------------------------------------------
#include "DxLib.h"
 
#define  WHITE      255,255,255     // 白(最大輝度白色光)  255
#define  YELLOW     255,255,  0     // 明るい黄色            251
 
#define  WAIT       (120)           // 全体のウェイト
 
//-----------------------------------------------------------------------------
// 馬の構造体
//-----------------------------------------------------------------------------
struct SHorse {
    int   x, y;
    char *horse;
 
    SHorse(){               // コンストラクタ
        x=0; y=0;
        horse = "/■^";        // 馬
    }
};
 
//-----------------------------------------------------------------------------
// エントリーポイント
//-----------------------------------------------------------------------------
int WINAPI WinMain( HINSTANCE, HINSTANCE, LPSTR, int )
{
    int White  = GetColor(WHITE);
    int Yellow = GetColor(YELLOW);
    int i;
    int n;          // 馬の数
    SHorse *p;      // 構造体へのポインタ
   
    ChangeWindowMode(TRUE);
    if( DxLib_Init() < 0 ) return -1;
    ChangeFont( "MS ゴシック" ) ;
    SetFontThickness(1);            // 文字の太さを1ドットにする
    SetDrawScreen( DX_SCREEN_BACK ) ;
 
lavel:
    DrawString(250, 150, "馬の数?", Yellow) ;
    n = KeyInputNumber(250+72 , 150 , 12 , 1 , TRUE ) ;
    p = new SHorse[n];
   
    while(!ProcessMessage() && !ClearDrawScreen())
    {
        DrawLine(72*8, 0, 72*8, 400, White);
        for(i=0; i<n ; i++){
            p[i].x += GetRand(20)+1;
            DrawString(p[i].x, i*32+20, p[i].horse, White) ;
        }
        ScreenFlip();
 
        for(i=0; i<n ; i++){
            if(p[i].x > (68*8)){    // ゴール
                delete []p;
                if(WaitKey()==KEY_INPUT_ESCAPE){    // [ESC]で終了
                    goto end;
                }
                goto lavel;
            }
        }
        Beep(1000, 10);Beep(1000, 5);
        WaitTimer(WAIT);                // ゲーム全体のウェイト
    }
    delete []p;     // ねんのため
end:
    DxLib_End();    // DXライブラリの後始末
    return 0;
}

Name: どぶろく
[URL]
プログラマー(30,434 ポイント)
Date: 2017年12月26日(火) 20:01
No: 11
(OFFLINE)

 Re: ぷるぷるプログラミング

ちまたで大反響!思わず手がぷるぷるしてくる。
さあ、老眼と手の震えがきたら、ぷるぷるプログラミングのはじまりだ!

●目的●
どこからか一羽のカラスが大きな柿の木に飛んできて、その実を全部食べてしまいます。

●内容●
カラスの動きは上下左右に変化します。縦横とも乱数によって -1 から 1 の範囲で求めます。
X座標の範囲は 1 から 38 まで、Y座標の範囲は 1 から 26 までとしています。
また、柿を食べると幹と枝が表示されるようにしています。

●応用●
このように乱数を利用して、いろいろなプログラムを考えて下さい。


コード[C++]: 全て選択
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
//-----------------------------------------------------------------------------
//  2017-12-26(火)
//
//  柿を食べるカラス
//
//-----------------------------------------------------------------------------
#include "DxLib.h"
#include "memory.h"
 
#define  WHITE      255,255,255     // 白(最大輝度白色光)  255
#define  WAIT       (150)           // 全体のウェイト
 
//-----------------------------------------------------------------------------
// 柿の実
//-----------------------------------------------------------------------------
char kaki[30][80]={
"                                                                              ",
"                                                                              ",
"                                                                              ",
"                                                                              ",
"                                                                              ",
"                                    ●●●                                    ",
"                                  ●●●●●                                  ",
"                                ●●●●●●●                                ",
"                              ●●●●●●●●●                              ",
"                            ●●●●●●●●●●●                            ",
"                          ●●●●●●●●●●●●●                          ",
"                        ●●●●●●●●●●●●●●●                        ",
"                      ●●●●●●●●●●●●●●●●●                      ",
"                    ●●●●●●●●●●●●●●●●●●●                    ",
"                  ●●●●●●●●●●●●●●●●●●●●●                  ",
"                ●●●●●●●●●●●●●●●●●●●●●●●                ",
"              ●●●●●●●●●●●●●●●●●●●●●●●●●              ",
"            ●●●●●●●●●●●●●●●●●●●●●●●●●●●            ",
"          ●●●●●●●●●●●●●●●●●●●●●●●●●●●●●          ",
"        ●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●        ",
"              ●●●●●●●●●●●●●●●●●●●●●●●●●              ",
"                    ●●●●●●●●●●●●●●●●●●●                    ",
"                          ●●●●●●●●●●●●●                          ",
"                                ●●●●●●●                                ",
"                                                                              ",
"                                                                              ",
"                                                                              ",
"                                                                              ",
"                                                                              ",
"                                                                              "
};
//-----------------------------------------------------------------------------
// 柿の木(幹と枝)
//-----------------------------------------------------------------------------
void kakinoki()
{
    int White  = GetColor(WHITE);
   
    DrawLine(316,  96, 288, 464, White);
    DrawLine(316,  96, 336, 464, White);
 
    DrawLine(170, 250, 300, 310, White);
    DrawLine(170, 250, 299, 325, White);
 
    DrawLine(210, 230, 220, 273, White);
    DrawLine(165, 300, 230, 287, White);
 
    DrawLine(450, 240, 325, 270, White);
    DrawLine(450, 240, 329, 281, White);
 
    DrawLine(390, 260, 450, 280, White);
    DrawLine(370, 260, 405, 216, White);
 
    DrawLine(220, 170, 305, 220, White);
    DrawLine(220, 170, 305, 230, White);
 
    DrawLine(240, 155, 253, 190, White);
 
    DrawLine(375, 135, 320, 165, White);
    DrawLine(375, 135, 320, 170, White);
 
    DrawLine(370, 150, 350, 150, White);
}
 
//-----------------------------------------------------------------------------
// エントリーポイント
//-----------------------------------------------------------------------------
int WINAPI WinMain( HINSTANCE, HINSTANCE, LPSTR, int )
{
    int White  = GetColor(WHITE);
    int i, j, x=0, y=0;
   
    ChangeWindowMode(TRUE);
    if( DxLib_Init() < 0 ) return -1;
    ChangeFont( "MS ゴシック" ) ;
    SetFontThickness(1);                // 文字の太さを1ドットにする
    SetDrawScreen( DX_SCREEN_BACK ) ;
 
    while(!ProcessMessage() && !ClearDrawScreen())
    {
        kakinoki();                 // 柿の木の幹と枝を表示
        for(j=0; j<30; j++){        // 柿の実を表示
            for(i=0; i<40; i++){
                DrawString(i*16, j*16, &kaki[j][i*2], White);
            }
        }
        x+=(GetRand(2)-1);
        y+=(GetRand(2)-1);
        if(x<1) { x= 1; }
        if(x>38){ x=38; }
        if(y<1) { y= 1; }
        if(y>26){ y=26; }
       
        if(!memcmp(&kaki[y][x*2], "●", 2)){
            kaki[y][x*2  ] = ' ';
            kaki[y][x*2+1] = ' ';
        }
        DrawString(x*16, y*16, "W", White);
        ScreenFlip();
        WaitTimer(WAIT);                // ゲーム全体のウェイト
    }
    DxLib_End();    // DXライブラリの後始末
    return 0;
}

Name: どぶろく
[URL]
プログラマー(30,434 ポイント)
Date: 2018年1月01日(月) 18:30
No: 12
(OFFLINE)

 Re: ぷるぷるプログラミング

あけましておめでとうございます。
今年も、ぷるぷるプログラミングをよろしくおねがいいたします。
さっそく、ぷるぷるしてプログラムが出来上がりました。

●目的●
道の幅は16文字分あり、そこに乱数によって障害物を発生させます。障害物にぶつかると
ゲームは終了となります。
カーソルキーを使って、ぶつからないようにうまくコントロールしてください。

●応用●
スピードを変えたり、道幅を変えたりしてプログラムを少し変更するだけで、もっと面白
くなります。また、指定回数分だけぶつかったら終了するようにしてもよいでしょう。


コード[C++]: 全て選択
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
//-----------------------------------------------------------------------------
//  2018-01-01(月)
//
//  通り抜けゲーム
//
//-----------------------------------------------------------------------------
#include "DxLib.h"
 
#define WHITE       255,255,255     // 白(最大輝度白色光)  255
#define RED         255,  0,  0     // 明るい赤              249
 
//-----------------------------------------------------------------------------
// 障害物の構造体
//-----------------------------------------------------------------------------
struct SObst {
    int x;
    int y;
};
//-----------------------------------------------------------------------------
// エントリーポイント
//-----------------------------------------------------------------------------
int WINAPI WinMain( HINSTANCE, HINSTANCE, LPSTR, int )
{
    int White = GetColor(WHITE);    // 文字色
    int Red   = GetColor(RED);
    int score=0;        // スコア
    int HiScore=0;      // ハイスコア
    int wait=150;       // ウェイト
    int a=20;           // 自分の初期位置(x座標)
    int rol=0;          // 障害物の配列番号
    int speed=0;        // スピードの変化用
    int key;            // キー押し下げ
    SObst obst[25];     // 障害物のx座標とy座標を保存する構造体
 
    ChangeWindowMode(TRUE);
    if( DxLib_Init() < 0 ) { return -1; };
    ChangeFont( "MS ゴシック" ) ;
    SetFontThickness(1);                // 文字の太さを1ドットにする
    SetDrawScreen( DX_SCREEN_BACK ) ;
 
    memset(obst, 0, sizeof(SObst)*25);  // 0で初期化
 
    while(!ProcessMessage() && !ClearDrawScreen())
    {
        key = GetJoypadInputState( DX_INPUT_KEY_PAD1 ) ;
 
        if( key & PAD_INPUT_9 )     { break; }  // ESCで終了
        if( key & PAD_INPUT_LEFT )  { a--;   }  // [←]キー
        if( key & PAD_INPUT_RIGHT ) { a++;   }  // [→]キー
 
        if( a<10 ) { a=10; }        // 左端にきたら
        if( a>25 ) { a=25; }        // 右端にきたら
       
        DrawLine(8*9,  0, 8*9,  26*16, White);
        DrawLine(8*27, 0, 8*27, 26*16, White);
        DrawString(a*8, 16, "&", White);
 
        obst[rol].x = GetRand(15)+10;   // 乱数で障害物の表示位置(x座標)を決める
        obst[rol].y = 24;               // y座標は一番下から
 
        for(int i=0; i<25 ; i++){        
            if((obst[i].x==a) && (obst[i].y==1)){       // 当たり判定
                DrawString(obst[i].x*8, obst[i].y*16, "●", Red);
                DrawString(14*8, 10*16, "game over", Red);
                DrawFormatString(29*8, 0, White, "%d  score %d", HiScore, score);
                ScreenFlip() ;
                if(HiScore<score){
                    HiScore=score;
                }
                Beep(700, 1000);
                if(WaitKey()==KEY_INPUT_ESCAPE){
                    goto end;
                }
                memset(obst, 0, sizeof(SObst)*25);
                a=20; rol=0; speed=0; wait=150; score=0;
            }
            DrawString(obst[i].x*8, obst[i].y*16, "*", White); // 障害物を表示
            obst[i].y--;        // 表示後のy座標を1つ上にする。
        }
        rol++;
        if(rol>24){
            rol=0;              // 障害物の配列番号をセットしていくため
        }
        speed++;
        if(speed>60){
            speed=0;
            wait-=10;           // だんだんスピードを速くする
            if(wait<30){ wait=150; }
        }
        score++;
        DrawFormatString(29*8, 0, White, "%d  score %d", HiScore, score);
        ScreenFlip() ;
        WaitTimer(wait);        // ゲーム全体のウェイト
    }
end:
    DxLib_End();        // DXライブラリの後始末
    return 0;
}

Name: どぶろく
[URL]
プログラマー(30,434 ポイント)
Date: 2018年1月06日(土) 17:41
No: 13
(OFFLINE)

 Re: ぷるぷるプログラミング

どうも、ちまたで、うわさの、ぷるぷるプログラミングです。
なんだか今年も絶好調だよ。
ところで文字にハートとかクラブとかあったと思ってたけど無かった・・・。
というわけで、グラフィックを作ってみました。
ちっちゃい絵だね~。もっと大きく作れば良かったなぁ・・・。

●目的●
動いているタマをキャッチして得点を競うゲームです。
前回の避けゲーとは逆の感じ。避けるのではなくキャッチしていきます。

●内容●
ミットのコントロールは、カーソルキー(左右のみ)で行い、制限時間は1分となっています。
タマの発生場所と種類は乱数によって設定します。タマの種類と得点は次のとおりです。

ハート 10点
ダイヤ 20点
クラブ -10点
スペード -20点

●応用●
タマの種類は乱数によって均等に発生していますが、種類によって発生確率をかえてみるとよいでしょう。
例)乱数を1から10の範囲で発生させて、その値によって次のようにします。

1~2 ダイヤ
3~6 ハート
7~9 クラブ
10 スペード

コード[C++]: 全て選択
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
//-----------------------------------------------------------------------------
//  2018-01-03(水)
//
//  キャッチゲーム
//
//-----------------------------------------------------------------------------
#include "DxLib.h"
 
#define WHITE       255,255,255     // 白(最大輝度白色光)    255
#define CYAN          0,255,255     // シアン(水色:輝淡青色)254
#define MAGENTA     255,  0,255     // マゼンタ(紫:淡紅色)  253
#define BLUE          0,  0,255     // 明るい青                252
#define YELLOW      255,255,  0     // 明るい黄色              251
#define GREEN         0,255,  0     // 明るい緑                250
#define RED         255,  0,  0     // 明るい赤                249
#define BLACK         0,  0,  0     // 黒                        0
 
#define WAIT        (130)           // 全体のウェイト
#define TIME        (60)            // 制限時間(60秒)
 
//-----------------------------------------------------------------------------
// マークの構造体
//-----------------------------------------------------------------------------
struct SMark {
    int x;
    int y;
    int m;  // マークの種類(0~3を入れる)
};
 
//-----------------------------------------------------------------------------
// マーク(ハート、ダイヤ、クラブ、スペード)
//-----------------------------------------------------------------------------
char g_img1[16][9] ={
    "        ",
    "        ",
    "        ",
    "        ",
    " RR  RR ",
    "RRR  RRR",
    "RRRRRRRR",
    "RRRRRRRR",
    "RRRRRRRR",
    "RRRRRRRR",
    " RRRRRR ",
    " RRRRRR ",
    "  RRRR  ",
    "  RRRR  ",
    "   RR   ",
    "        "
};
 
char g_img2[16][9] ={
    "        ",
    "   YY   ",
    "   YY   ",
    "  YYYY  ",
    "  YYYY  ",
    " YYYYYY ",
    " YYYYYY ",
    "YYYYYYYY",
    "YYYYYYYY",
    " YYYYYY ",
    " YYYYYY ",
    "  YYYY  ",
    "  YYYY  ",
    "   YY   ",
    "   YY   ",
    "        "
};
 
char g_img3[16][9] ={
    "        ",
    "        ",
    "   SS   ",
    "  SSSS  ",
    "  SSSS  ",
    "  SSSS  ",
    "   SS   ",
    " SSSSSS ",
    "SSSSSSSS",
    "SSSSSSSS",
    "SSSSSSSS",
    " S SS S ",
    "   SS   ",
    "   SS   ",
    "  SSSS  ",
    "        "
};
 
char g_img4[16][9] ={
    "        ",
    "        ",
    "        ",
    "   GG   ",
    "  GGGG  ",
    "  GGGG  ",
    " GGGGGG ",
    " GGGGGG ",
    "GGGGGGGG",
    "GGGGGGGG",
    "GGGGGGGG",
    "GGGGGGGG",
    " G GG G ",
    "   GG   ",
    "   GG   ",
    "        "
};
 
//-----------------------------------------------------------------------------
// パレットに色をセットする
//-----------------------------------------------------------------------------
void set_pal(int hImg)
{
    SetPaletteSoftImage( hImg, 0, BLACK, 0 ) ;
    SetPaletteSoftImage( hImg, 1, WHITE, 0 ) ;
    SetPaletteSoftImage( hImg, 2, YELLOW, 0 ) ;
    SetPaletteSoftImage( hImg, 3, CYAN, 0 ) ;
    SetPaletteSoftImage( hImg, 4, MAGENTA, 0 ) ;
    SetPaletteSoftImage( hImg, 5, GREEN, 0 ) ;
}
 
//-----------------------------------------------------------------------------
// ドット絵を描く
//-----------------------------------------------------------------------------
void make_dot(int hImg, char (*img)[9])
{
    int x, y, c;
 
    for( y=0; y<16 ; y++ ){
        for( x=0; x<8 ; x++ ){
            c=0;
            if(img[y][x]==' '){ c=0; }  // BLACK
            if(img[y][x]=='Y'){ c=2; }  // YELLOW
            if(img[y][x]=='S'){ c=3; }  // CYAN
            if(img[y][x]=='R'){ c=4; }  // MAGENTA
            if(img[y][x]=='G'){ c=5; }  // GREEN
 
            DrawPixelPalCodeSoftImage( hImg, x, y, c ) ;
        }
    }
}
 
//-----------------------------------------------------------------------------
// 右に得点表を表示する
//-----------------------------------------------------------------------------
void put_tokuten(int hGraph[])
{
    int White  = GetColor(WHITE);
    int Yellow = GetColor(YELLOW);
 
    DrawBox(43*8, 2*16, 53*8, 11*16, White, FALSE);
 
    DrawGraph(45*8, 3*16, hGraph[0], FALSE);        // ハートを表示
    DrawGraph(45*8, 5*16, hGraph[1], FALSE);        // ダイヤを表示
    DrawGraph(45*8, 7*16, hGraph[2], FALSE);        // クラブを表示
    DrawGraph(45*8, 9*16, hGraph[3], FALSE);        // スペードを表示
 
    DrawString(48*8, 3*16, " 10", Yellow);          // ハートの点数を表示
    DrawString(48*8, 5*16, " 20", Yellow);          // ダイヤの点数を表示
    DrawString(48*8, 7*16, "-10", Yellow);          // クラブの点数を表示
    DrawString(48*8, 9*16, "-20", Yellow);          // スペードの点数を表示
}
 
//-----------------------------------------------------------------------------
// 終わりの処理
//-----------------------------------------------------------------------------
int owari(int &HiScore, int score, int time1)
{
    int White  = GetColor(WHITE);
    int Black  = GetColor(BLACK);
    int Yellow = GetColor(YELLOW);
 
    DrawBox(0, 0, 38*8, 16, Black, TRUE);
    DrawFormatString(0, 0, White, " HiScore %d  score %d  time %d/%d", HiScore, score, time1/1000, TIME);
    DrawBox(6*16, 8*16, 16*16, 15*16, Black, TRUE);
    DrawBox(6*16, 8*16, 16*16, 15*16, Yellow, 0);
    DrawString(8*16,  9*16, "  TIME UP", Yellow);
    DrawString(8*16, 11*16, "HIT ANY KEY", White);
    DrawString(8*16, 13*16, "[ESC] 終了", White);
    ScreenFlip() ;
    Beep(1000,1000);
    WaitTimer(1000);
 
    if(WaitKey()==KEY_INPUT_ESCAPE){
        return 1;
    }
    if(HiScore < score){
        HiScore = score;
    }
    return 0;
}
//-----------------------------------------------------------------------------
// エントリーポイント
//-----------------------------------------------------------------------------
int WINAPI WinMain( HINSTANCE, HINSTANCE, LPSTR, int )
{
    int White = GetColor(WHITE);
    int Black = GetColor(BLACK);
    int score=0;                // スコア
    int HiScore=0;              // ハイスコア
    int a=20;                   // 自分のx座標
    int rol=0;                  // 障害物の配列番号
    int key;                    // キー押し下げ
    int hImg[4];                // パレット画像のハンドル
    int hGraph[4];              // グラフィックハンドル
    int StartTime, time1=0;     // 時間
    SMark mark[25];             // マークの構造体
 
    memset(mark, 0, sizeof(SMark)*25);  // 0で初期化
 
    ChangeWindowMode(TRUE);
    if( DxLib_Init() < 0 ){ return -1; }
    ChangeFont( "MS ゴシック" ) ;
    SetFontSize( 16 ) ;
    SetFontThickness( 1 );              // 文字の太さを1ドットにする
    SetAlwaysRunFlag( TRUE ) ;          // バックグランドでも実行する
    SetDrawScreen( DX_SCREEN_BACK ) ;
 
    // 空のパレット画像を作成する
    hImg[0] = MakePAL8ColorSoftImage( 8, 16 ) ;
    hImg[1] = MakePAL8ColorSoftImage( 8, 16 ) ;
    hImg[2] = MakePAL8ColorSoftImage( 8, 16 ) ;
    hImg[3] = MakePAL8ColorSoftImage( 8, 16 ) ;
 
    // パレットに色をセットする
    set_pal(hImg[0]);
    set_pal(hImg[1]);
    set_pal(hImg[2]);
    set_pal(hImg[3]);
 
    //ドット絵を描く
    make_dot(hImg[0], g_img1);  // ハート
    make_dot(hImg[1], g_img2);  // ダイヤ
    make_dot(hImg[2], g_img3);  // クラブ
    make_dot(hImg[3], g_img4);  // スペード
 
    // グラフィックハンドルを作成
    hGraph[0] = CreateGraphFromSoftImage( hImg[0] ) ;
    hGraph[1] = CreateGraphFromSoftImage( hImg[1] ) ;
    hGraph[2] = CreateGraphFromSoftImage( hImg[2] ) ;
    hGraph[3] = CreateGraphFromSoftImage( hImg[3] ) ;
 
    // 使い終わったら解放
    DeleteSoftImage( hImg[0] ) ;
    DeleteSoftImage( hImg[1] ) ;
    DeleteSoftImage( hImg[2] ) ;
    DeleteSoftImage( hImg[3] ) ;
 
    StartTime = GetNowCount();
 
    while(!ProcessMessage() && !ClearDrawScreen())
    {
        key = GetJoypadInputState( DX_INPUT_KEY_PAD1 ) ;
 
        if( key & PAD_INPUT_9 )    { break; }   // ESCで終了
        if( key & PAD_INPUT_LEFT ) { a--;   }   // [←]キー
        if( key & PAD_INPUT_RIGHT ){ a++;   }   // [→]キー
 
        if( a<0 ) { a=0; }          // 左端にきたら
        if( a>36 ){ a=36; }         // 右端にきたら
       
        DrawString(a*8, 3*16, "|--|", White);
        put_tokuten(hGraph);        // 得点表を表示
       
        mark[rol].m = GetRand(3);   // 乱数でマークの種類を決める
        mark[rol].x = GetRand(37)+1;// 乱数でマークの表示位置(x座標)を決める
        mark[rol].y = 24;           // y座標は一番下から
       
        for(int i=0; i<25 ; i++){
            if((mark[i].x >= a+1) && (mark[i].x <= a+2) && (mark[i].y == 3)){   // 当たり判定
                if(mark[i].m==0){ score+=10; Beep(1000, 30);}                   // ハート
                if(mark[i].m==1){ score+=20; Beep(1500, 30);Beep(1000, 30);}    // ダイヤ
                if(mark[i].m==2){ score-=10; Beep( 500, 30);}                   // クラブ
                if(mark[i].m==3){ score-=20; Beep( 500, 30);Beep( 500, 30);}    // スペード
            }
            DrawGraph( mark[i].x*8, mark[i].y*16, hGraph[mark[i].m], FALSE ) ;  // 描画
            mark[i].y--;        // 表示後のy座標を1つ上にする。
        }
        rol++;
        if(rol>24){
            rol=0;              // マークの配列番号をセットしていくため
        }
        if(time1>TIME*1000){    // 60秒過ぎたら
            if(owari(HiScore, score, time1)){
                goto end;
            }
            memset(mark, 0, sizeof(SMark)*25);      // 0で初期化
            rol=0; score=0; StartTime=GetNowCount();
        }
        time1 = GetNowCount() - StartTime;          // 経過時間
 
        DrawBox(0, 0, 38*8, 16, Black, TRUE);
        DrawFormatString( 0, 0, White, " HiScore %d  score %d  time %d/%d", HiScore, score, time1/1000, TIME);
 
        ScreenFlip() ;
        WaitTimer(WAIT);        // ゲーム全体のウェイト
    }
end:
    for(int i=0; i<4 ; i++){
        DeleteGraph( hGraph[i] );   // グラフィックハンドルの削除
    }
    DxLib_End();                // DXライブラリの後始末
    return 0;
}

Name: どぶろく
[URL]
プログラマー(30,434 ポイント)
Date: 2018年1月11日(木) 18:11
No: 14
(OFFLINE)

 Re: ぷるぷるプログラミング

どうも、ちまたで、ちまった、ぷるぷるプログラミングです。
今回で、ちまったのだ。いや~、面白かったねぇ。
何個ゲーム作ったか覚えてないけど。(笑)
BASIC面白かったよぉ。今度はHSPを勉強して移植しようかな。
では、ちまたで、ちまった、ゲームを堪能してください。

●目的●
カーソルキー(上、下、左、右)を使って、トンボを採るゲームです。

●内容●
発生するトンボ(T)を、網(○)で採った分だけ得点となります。
時間は1分にしてあります。
乱数を利用して、トンボを表示しているわけですが、ゆっくりしていると、
トンボはどんどん移動していきます。
また、トンボを採ると音が発生するようにしました。

●応用●
トンボ採りの場所の形(現在は正方形)を変えたり、障害物(木とか池)などを画面上に
表示させると、もっと高度なゲームになります。
また、他の昆虫なども表示するよう考えてみてください。

コード[C++]: 全て選択
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
//-----------------------------------------------------------------------------
//  2018-01-11(木)
//
//  トンボ採りゲーム
//
//-----------------------------------------------------------------------------
#include "DxLib.h"
 
#define WHITE       255,255,255     // 白(最大輝度白色光)    255
#define YELLOW      255,255,  0     // 明るい黄色              251
#define BLACK         0,  0,  0     // 黒                        0
 
#define WAIT        (150)           // 全体のウェイト
#define TIME        (60)            // 制限時間(60秒)
#define TOMBO       (17)            // トンボの数
#define SPEED       (2)             // トンボのスピード(大きくすると遅くなる)
 
//-----------------------------------------------------------------------------
// トンボの構造体
//-----------------------------------------------------------------------------
struct STombo {
    int x;
    int y;
};
 
//-----------------------------------------------------------------------------
// 得点を表示
//-----------------------------------------------------------------------------
void put_score(int HiScore, int score, int time1)
{
    int White  = GetColor(WHITE);
    int Black  = GetColor(BLACK);
 
    DrawBox(28*16, 2*16, 36*16, 7*16, Black, TRUE);
    DrawFormatString(28*16, 2*16, White, "HiScore %d", HiScore);
    DrawFormatString(28*16, 4*16, White, "Score   %d", score);
    DrawFormatString(28*16, 6*16, White, "Time %3d/%d", time1/1000, TIME);
}
 
//-----------------------------------------------------------------------------
// 終わりの処理
//-----------------------------------------------------------------------------
int owari(int& HiScore, int score, int time1)
{
    int White  = GetColor(WHITE);
    int Black  = GetColor(BLACK);
    int Yellow = GetColor(YELLOW);
 
    put_score(HiScore, score, time1);
   
    DrawBox(8*16, 8*16, 18*16, 15*16, Black, TRUE);
    DrawBox(8*16, 8*16, 18*16, 15*16, Yellow, 0);
    DrawString(11*16,    9*16, "TIME UP", Yellow);
    DrawString(10*16,   11*16, "HIT ANY KEY", White);
    DrawString(10*16+4, 13*16, "[ESC] 終了", White);
    ScreenFlip() ;
    Beep(1000,1000);
    WaitTimer(300);
 
    if(WaitKey()==KEY_INPUT_ESCAPE){
        return 1;
    }
    if(HiScore < score){
        HiScore = score;
    }
    return 0;
}
//-----------------------------------------------------------------------------
// エントリーポイント
//-----------------------------------------------------------------------------
int WINAPI WinMain( HINSTANCE, HINSTANCE, LPSTR, int )
{
    int White = GetColor(WHITE);
    int Yellow= GetColor(YELLOW);
    int score=0;            // スコア
    int HiScore=0;          // ハイスコア
    int x=12, y=12;         // 自分の位置
    int speed=0;            // トンボのスピードカウンタ
    int time1=0;            // 経過時間
    int StartTime;          // スタート時間
    int key;                // キー押し下げ
    STombo tombo[TOMBO];    // トンボの構造体
 
    ChangeWindowMode(TRUE);
    if( DxLib_Init() < 0 ){ return -1; }
    ChangeFont( "MS ゴシック" ) ;
    SetFontSize( 16 ) ;
    SetFontThickness( 6 );              // 文字の太さを2ドットにする
    SetAlwaysRunFlag( TRUE ) ;          // バックグランドでも実行する
    SetDrawScreen( DX_SCREEN_BACK ) ;
 
    for(int i=0; i<TOMBO ; i++){        
        tombo[i].x = GetRand(24)+1;
        tombo[i].y = GetRand(24)+1;
    }
    StartTime = GetNowCount();
   
    while(!ProcessMessage() && !ClearDrawScreen())
    {
        key = GetJoypadInputState( DX_INPUT_KEY_PAD1 ) ;
 
        if( key & PAD_INPUT_9 )    { break; }   // ESCで終了
        if( key & PAD_INPUT_LEFT ) { x--;   }   // [←]キー
        if( key & PAD_INPUT_RIGHT ){ x++;   }   // [→]キー
        if( key & PAD_INPUT_UP )   { y--;   }   // [↑]キー
        if( key & PAD_INPUT_DOWN ) { y++;   }   // [↓]キー
 
        if( x<1 ) { x=1; }      // 左端にきたら
        if( x>25 ){ x=25;}      // 右端にきたら
        if( y<1 ) { y=1; }      // 上端にきたら
        if( y>25 ){ y=25;}      // 下端にきたら
       
        DrawBox(8, 8, 26*16+8, 26*16+8, White, FALSE);  // 枠を表示
        DrawString(x*16, y*16, "○", Yellow);          // 網を表示
 
        for(int i=0; i<TOMBO ; i++){        
            DrawString(tombo[i].x*16, tombo[i].y*16, "T", White); // トンボを表示
        }
        for(int i=0; i<TOMBO ; i++){        
            if((tombo[i].x==x) && (tombo[i].y==y)){     // 当たり判定
                put_score(HiScore, score, time1);
                ScreenFlip() ;
                score++;
                Beep(2000, 100);Beep(1000, 100);
                tombo[i].x = GetRand(24)+1;         // 新しくトンボを作る
                tombo[i].y = GetRand(24)+1;
            }
        }
        speed++;
        if(speed > SPEED){              // トンボのスピード調整
            speed=0;
            for(int i=0; i<TOMBO ; i++){        // トンボを動かす
                tombo[i].x += GetRand(2)-1;
                tombo[i].y += GetRand(2)-1;
                if( tombo[i].x<1 ) { tombo[i].x=1; }    // 左端にきたら
                if( tombo[i].x>25 ){ tombo[i].x=25;}    // 右端にきたら
                if( tombo[i].y<1 ) { tombo[i].y=1; }    // 上端にきたら
                if( tombo[i].y>25 ){ tombo[i].y=25;}    // 下端にきたら
            }
        }
        time1 = GetNowCount() - StartTime;      // 経過時間
 
        if(time1>TIME*1000){    // 60秒過ぎたら
            if(owari(HiScore, score, time1)){
                goto end;
            }
            x=12; y=12; score=0;
            StartTime = GetNowCount();
        }
        put_score(HiScore, score, time1);
        ScreenFlip() ;
        WaitTimer(WAIT);        // ゲーム全体のウェイト
    }
end:
    DxLib_End();        // DXライブラリの後始末
    return 0;
}

Name: どぶろく
[URL]
プログラマー(30,434 ポイント)
Date: 2018年1月16日(火) 19:18
No: 15
(OFFLINE)

 Re: ぷるぷるプログラミング

あちゃ~、 DxLib_Init 呼び出す前に GetColor 使っちゃったよ。戻り値も int じゃなく unsigned int じゃん。
WaitTimer も使っちゃてるし、ScreenFlip も複数使ってる、よく見れば goto も使ってる。
こうやって失敗を重ねて成長して行くんだね。また一つ(5つも)賢くなったのだ、のだ、野田の玉川。

Name: どぶろく
[URL]
プログラマー(30,434 ポイント)
Date: 2018年1月21日(日) 18:44
No: 16
(OFFLINE)

 Re: ぷるぷるプログラミング

画像データをキーボードでピコピコ打ち込んでいたのたが、
めっちゃ大変なのでドット絵エディターを作ることにしました。
もちろん色をアルファベット1文字にするために作成中です。

つまり、

コード[C++]: 全て選択
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
char img[32][33] ={
    "              b b               ",
    "              b b               ",
    "           bbbbYbbbb            ",
    "           bbbbYbbbb            ",
    "     RRRR bbCbbYbbCbb  RRRR     ",
    "     RRRR bbCbbYbbCbb  RRRR     ",
    "   CCCCgCC bbbbYbbbb  CCgCCCCC  ",
    "   CCCCgCC bbbbYbbbb  CCgCCCCC  ",
    "  CCCCCgCCCCCYYYYYYCCCCCgCCCCCC ",
    "  CCCCCgCCCCCYYYYYYCCCCCgCCCCCC ",
    " CCCCCCggggggYYYYYYggggggCCCCCCC",
    " CCCCCCggggggYYYYYYggggggCCCCCCC",
    " CCCCCCCCCCCCCYYYYCCCCCCCCCCCCCC",
    " CCCCCCCCCCCCCYYYYCCCCCCCCCCCCCC",
    "  CgggggggggggYYYYggggggggggCC  ",
    "  CgggggggggggYYYYggggggggggCC  ",
    "   gggggggggggYYYYgggggggg g    ",
    "   g gggggggggYYYYgggggggg g    ",
    "   g g     YYYYYYYYYY    g g    ",
    "   g g     YYYYYYYYYY    g g    ",
    "   g g   yyyyyyyyyyyyyy  g g    ",
    "   g g   yyyyyyyyyyyyyy  g g    ",
    " RRR g  YYYYYYYYYYYYYYYY g RRR  ",
    " RRR g  YYYYYYYYYYYYYYYY g RRR  ",
    "     g   yyyyyyyyyyyyyy  g      ",
    "     g   yyyyyyyyyyyyyy  g      ",
    "  RRRR    YYYYYYYYYYYY   RRRR   ",
    "  RRRR    YYYYYYYYYYYY   RRRR   ",
    "           yyyyyyyyyy           ",
    "           yyyyyyyyyy           ",
    "              YYYY              ",
    "              YYYY              "
};

こういうのを作るためのエディタ。

途中経過のエディターの画像をアップしようとしたけど、画像のアップの仕方が分かんなかった。
ということで、制作途中のソースだけどアップするので暇つぶしに見て下さい。
BMPファイルを変換する方が早いとも思ったが、そっちの方が大変だよね?

コード[C++]: 全て選択
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
//-----------------------------------------------------------------------------
//  2018-01-21(日)
//
//  ドット絵エディタ(色データを文字にする)
//
//-----------------------------------------------------------------------------
#include "DxLib.h"
 
#define DD_GRAY     85, 85, 85    // 暗い灰色         -1
#define BLACK        0,  0,  0    // 黒                0
#define D_RED      128,  0,  0    // 暗い赤            1
#define D_GREEN      0,128,  0    // 暗い緑            2
#define D_YELLOW   128,128,  0    // 暗い黄色(深黄色)3
#define D_BLUE       0,  0,128    // 暗い青            4
#define D_MAGENTA  128,  0,128    // 暗いマゼンタ      5
#define D_CYAN       0,128,128    // 暗いシアン        6
 
#define MD_RED     191,  0,  0    // やや暗い赤             _1
#define MD_GREEN     0,191,  0    // やや暗い緑             _2
#define MD_YELLOW  191,191,  0    // やや暗い黄色(黄銅色) _3
#define MD_BLUE      0,  0,191    // やや暗い青             _4
#define MD_MAGENTA 191,  0,191    // やや暗いマゼンタ       _5
#define MD_CYAN      0,191,191    // やや暗いシアン         _6
 
#define GRAY       192,192,192    // 明るい灰色              7
#define M_GREEN    192,220,192    // マネーグリーン          8
#define S_BLUE     166,202,240    // スカイブルー            9
 
//#define CREAM      255,251,240    // クリーム(淡黄色)      246
#define CREAM      255,251,200    // クリーム(淡黄色)      246
#define M_GRAY     160,160,164    // ミディアムグレー        247
#define D_GRAY     128,128,128    // 暗い灰色                248
#define RED        255,  0,  0    // 明るい赤                249
#define GREEN        0,255,  0    // 明るい緑                250
#define YELLOW     255,255,  0    // 明るい黄色              251
#define BLUE         0,  0,255    // 明るい青                252
#define MAGENTA    255,  0,255    // マゼンタ(紫:淡紅色)  253
#define CYAN         0,255,255    // シアン(水色:輝淡青色)254
#define WHITE      255,255,255    // 白(最大輝度白色光)    255
#define L_BLUE      0,150,255     // ライトブルー
 
//-----------------------------------------------------------------------------
// 構造体
//-----------------------------------------------------------------------------
struct SDot{
    int   L_x;          // 左ボタンで選択した色に L を付けるため
    int   R_x;          // 右ボタンで選択した色に R を付けるため
    UINT  L_color;      // 左ボタンで選択した色
    UINT  R_color;      // 右ボタンで選択した色
    UINT  mesh_color;   // メッシュの色
    UCHAR L_num;        // 左ボタンで選択した色の配列番号
    UCHAR R_num;        // 右ボタンで選択した色の配列番号
    UCHAR masu[35][60]; // 色データを格納
};
 
//-----------------------------------------------------------------------------
// グローバル変数
//-----------------------------------------------------------------------------
SDot g_dot;
 
 
//-----------------------------------------------------------------
// スタティックカラーをセット
//-----------------------------------------------------------------
void set_color(UINT aColor[])
{
    aColor[ 0] = GetColor(BLACK);
    aColor[ 1] = GetColor(D_RED);
    aColor[ 2] = GetColor(D_GREEN);
    aColor[ 3] = GetColor(D_YELLOW);
    aColor[ 4] = GetColor(D_BLUE);
    aColor[ 5] = GetColor(D_MAGENTA);
    aColor[ 6] = GetColor(D_CYAN);
    aColor[ 7] = GetColor(GRAY);
    aColor[ 8] = GetColor(M_GREEN);
    aColor[ 9] = GetColor(S_BLUE);
 
    aColor[10] = GetColor(CREAM);
    aColor[11] = GetColor(M_GRAY);
    aColor[12] = GetColor(D_GRAY);
    aColor[13] = GetColor(RED);
    aColor[14] = GetColor(GREEN);
    aColor[15] = GetColor(YELLOW);
    aColor[16] = GetColor(BLUE);
    aColor[17] = GetColor(MAGENTA);
    aColor[18] = GetColor(CYAN);
    aColor[19] = GetColor(WHITE);
}
 
//-----------------------------------------------------------------------------
// パレット表示
//-----------------------------------------------------------------------------
void put_pallet(UINT aColor[])
{
    UINT White = GetColor(WHITE);
    UINT Black = GetColor(BLACK);
    UINT Gray  = GetColor(GRAY);
   
    set_color(aColor);
 
    for(int i=0 ; i<20 ; i++){
        DrawBox(224+(20*i), 7, 243+(20*i), 41, aColor[i], TRUE);    // 色を表示
    }
    DrawBox(222, 5, 245+(20*19), 43, Gray, FALSE);          // 色の枠
 
    // 色選択時、左ボタン(L)か、右ボタン(R)かを表示
    DrawBox(g_dot.L_x-1, 14, g_dot.L_x+8, 14+16, White, TRUE);
    DrawBox(g_dot.R_x-1, 14, g_dot.R_x+8, 14+16, White, TRUE);
    DrawString(g_dot.L_x, 14, "L", Black);
    DrawString(g_dot.R_x, 14, "R", Black);
}
 
//-----------------------------------------------------------------
// ディスプレイ画面
//-----------------------------------------------------------------
void disp(UINT aColor[])
{
    UINT White = GetColor(WHITE);
    UINT Blue  = GetColor(BLUE);
    UINT Gray  = GetColor(GRAY);
    int  x, y;
 
    DrawBox(2, 5, 140, 35, Gray, FALSE);    // メニュー枠を表示
    DrawString(8, 12, "読込  保存  消去", White); // メニューを表示
 
    //DrawBox(150, 5, 213, 45, Gray, FALSE);    // 実寸画像用の枠を表示
 
    put_pallet(aColor);
 
    //------ 縦と横の線(お絵かき画面作成)----------------
 
    for(y=80 ; y<=420 ; y+=10){             // 10ドット単位の横線
        DrawLine(40, y, 640, y, Blue);
    }
    for(y=80 ; y<=430 ; y+=50){             // 50ドット単位の横線
        DrawLine(30, y, 650, y, Blue);
    }
 
    for(x=40 ; x<=640 ; x+=10){             // 10ドット単位の縦線
        DrawLine(x, 80, x, 430, Blue);
    }
    for(x=40 ; x<=640 ; x+=50){             // 50ドット単位の縦線
        DrawLine(x, 70, x, 440, Blue);
    }
 
    for(x=135; x<=640 ; x+=100){
        DrawFormatString(x, 50, White, "%d", x/10-3);   // 横ドット数を表示
    }
    for(y=170; y<=430 ; y+=100){
        DrawFormatString(10, y, White , "%d", y/10-7);  // 縦ドット数を表示
    }
}
 
//-----------------------------------------------------------------
// マウスによる色の選択
//-----------------------------------------------------------------
void select_color(int x, UINT aColor[], int LR)
{
    int n;
 
    n = (x-225)/20;             // 選択色をセット
    x = n * 20 + 230;           // 座標を計算
 
    if(LR==1){
        g_dot.L_color = aColor[n];
        g_dot.L_x = x;              // x座標を保存
        g_dot.L_num = (UCHAR)n;     // 色の配列番号
    }
    else {
        g_dot.R_color = aColor[n];
        g_dot.R_x = x;              // x座標を保存
        g_dot.R_num = (UCHAR)n;     // 色の配列番号
    }
}
 
//-----------------------------------------------------------------------------
// マスを塗る(ドット絵作成)
//-----------------------------------------------------------------------------
void draw_dot(int x,int y, int LR)
{
    UINT Black = GetColor(BLACK);
    UINT White = GetColor(WHITE);
    int  mx, my;
 
    if((x>=40 && x<640) && (y>=80 && y<430)){
        mx = x/10;          // 配列に入れるため。
        my = y/10;
        x  = x/10*10;       // 10ドット単位にするため端数を切り捨てる
        y  = y/10*10;
 
        if(LR==1){  // 左ボタン
            DrawBox(x+1, y+1, x+10, y+10, g_dot.L_color, TRUE); // マスを塗る
            DrawPixel(mx+148, my, g_dot.L_color);
            g_dot.masu[my-8][mx-4] = g_dot.L_num;
        }
        else {      // 右ボタン
            DrawBox(x+1, y+1, x+10, y+10, g_dot.R_color, TRUE); // マスを塗る
            DrawPixel(mx+148, my, g_dot.R_color);
            g_dot.masu[my-8][mx-4] = g_dot.R_num;
        }
        DrawBox(40, 50, 50+10*8, 50+16, Black, TRUE);
        DrawFormatString(40, 50, White, "(%2d,%2d)", mx-3, my-7);   // 座標を表示
    }
}
 
//-----------------------------------------------------------------------------
// エントリーポイント
//-----------------------------------------------------------------------------
int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
{
    UINT aColor[20];
    int  x, y;
    int  Mouse;
   
    ChangeWindowMode(TRUE);
    SetGraphMode( 800 , 600 , 32 ) ;
    DxLib_Init();
    ChangeFont( "MS ゴシック" ) ;
    SetFontSize( 16 ) ;
    SetFontThickness( 1 );              // 文字の太さを1ドットにする
    SetDrawScreen( DX_SCREEN_BACK );
   
    g_dot.L_x = 230+19*20;
    g_dot.R_x = 230;
    UINT White = g_dot.L_color = GetColor(WHITE);
    UINT Black = g_dot.R_color = GetColor(BLACK);
   
    while( !ScreenFlip() && !ProcessMessage() /*&& !ClearDrawScreen()*/ )
    {
        Mouse = GetMouseInput();    // マウスの入力状態取得
        GetMousePoint( &x, &y );    // マウスの座標取得
 
        disp(aColor);
        DrawBox(40, 32*16, 50+10*8, 32*16+16, Black, TRUE);
        DrawFormatString(40, 32*16, White, "%d, %d  ", x, y);  // 座標を表示
       
        if( Mouse & MOUSE_INPUT_LEFT ){     //マウスの左ボタンが押された
            draw_dot(x, y, 1);
            if((x>225 && x<625) && (y>5 && y<40)){
                select_color(x, aColor, 1);     // 色を選択する
            }
            if((x>2 && x<140) && (y>5 && y<35)){
                //load_save(x, y);              // ロードとセーブ
            }
        }
        if( Mouse & MOUSE_INPUT_RIGHT ){    //マウスの左ボタンが押された
            draw_dot(x, y, 2);
            if((x>225 && x<625) && (y>5 && y<40)){
                select_color(x, aColor, 2);     // 色を選択する
            }
        }
    }
    DxLib_End();
    return 0;
}

Name: どぶろく
[URL]
プログラマー(30,434 ポイント)
Date: 2018年1月30日(火) 20:29
No: 17
(OFFLINE)

 Re: ぷるぷるプログラミング

ドット絵を保存できるようにしたので、アイコンを作ってみました。
このアイコンは自分でデザインしたわけじゃないけどね。BASIC の本に載ってたものです。
懐かしいなぁ、ここでも BASIC を再現してるよん。
本当は画面の上にアイコンが並んでるだけど、下に並べちゃった。
まだまだ完成はしてないけど、じゅうぶんに遊べる。早く保存したやつを読み込み出来るように
したいけど、ちょっと難しそうなんだよね。

コード[C++]: 全て選択
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
//-----------------------------------------------------------------------------
//  2018.01.21(日)~ 2018.01.30(火)
//
//  ドット絵エディタ(色データを文字にする)
//
//-----------------------------------------------------------------------------
#include "DxLib.h"
#include <stdio.h>
 
#define DD_GRAY     85, 85, 85    // 暗い灰色         -1
#define BLACK        0,  0,  0    // 黒                0
#define D_RED      128,  0,  0    // 暗い赤            1
#define D_GREEN      0,128,  0    // 暗い緑            2
#define D_YELLOW   128,128,  0    // 暗い黄色(深黄色)3
#define D_BLUE       0,  0,128    // 暗い青            4
#define D_MAGENTA  128,  0,128    // 暗いマゼンタ      5
#define D_CYAN       0,128,128    // 暗いシアン        6
 
#define MD_RED     191,  0,  0    // やや暗い赤             _1
#define MD_GREEN     0,191,  0    // やや暗い緑             _2
#define MD_YELLOW  191,191,  0    // やや暗い黄色(黄銅色) _3
#define MD_BLUE      0,  0,191    // やや暗い青             _4
#define MD_MAGENTA 191,  0,191    // やや暗いマゼンタ       _5
#define MD_CYAN      0,191,191    // やや暗いシアン         _6
 
#define GRAY       192,192,192    // 明るい灰色              7
#define M_GREEN    192,220,192    // マネーグリーン          8
#define S_BLUE     166,202,240    // スカイブルー            9
 
//#define CREAM      255,251,240    // クリーム(淡黄色)      246
#define CREAM      255,251,200    // クリーム(淡黄色)      246
#define M_GRAY     160,160,164    // ミディアムグレー        247
#define D_GRAY     128,128,128    // 暗い灰色                248
#define RED        255,  0,  0    // 明るい赤                249
#define GREEN        0,255,  0    // 明るい緑                250
#define YELLOW     255,255,  0    // 明るい黄色              251
#define BLUE         0,  0,255    // 明るい青                252
#define MAGENTA    255,  0,255    // マゼンタ(紫:淡紅色)  253
#define CYAN         0,255,255    // シアン(水色:輝淡青色)254
#define WHITE      255,255,255    // 白(最大輝度白色光)    255
#define L_BLUE      0,150,255     // ライトブルー
 
#define SCREEN_W    800
#define SCREEN_H    600
#define MESH_W      64
#define MESH_H      32
#define MAX_COLOR   256
#define MAX_PALLET  20
#define MAX_ICON    13
 
//----------------------------------------------------------------------
// 定数(遷移用)
//----------------------------------------------------------------------
enum EState {
    STATE_MAIN,
    STATE_PUT_ALPHA,
    STATE_LOAD,
    STATE_SAVE,
    STATE_MESH,
    STATE_CLEAR,
    STATE_END
};
 
//-----------------------------------------------------------------------------
// 構造体
//-----------------------------------------------------------------------------
struct SDot{
    int    L_x;         // 左ボタンで選択した色に L を付けるため
    int    R_x;         // 右ボタンで選択した色に R を付けるため
    UINT   L_color;     // 左ボタンで選択した色
    UINT   R_color;     // 右ボタンで選択した色
    UINT   mesh_nColor; // メッシュの色
    UCHAR  L_num;       // 左ボタンで選択した色番号
    UCHAR  R_num;       // 右ボタンで選択した色番号
    UCHAR  masu[MESH_H][MESH_W];    // 色データを格納(色番号)
    char   moji[MESH_H][MESH_W+5];  // 変換したアルファベットを格納
    char   alpha[MAX_COLOR];        // 変換するアルファベット
    EState eState;                  // 遷移用
};
 
//-----------------------------------------------------------------
// プロトタイプ宣言
//-----------------------------------------------------------------
EState main_dot(int x, int y, int Mouse, UINT aColor[]);
EState select_color(int x, UINT aColor[], int LR);
EState put_alpha(UINT aColor[], int hIcon[]);
EState put_mesh(UINT aColor[], int hIcon[]);
EState cls(UINT aColor[]);
EState save(UINT aColor[]);
void   set_pallet(UINT aColor[]);
void   put_pallet(UINT aColor[]);
void   put_dot(UINT aColor[]);
void   put_disp(UINT aColor[], int hIcon[]);
void   draw_dot(int x,int y, int LR);
void   put_icon(int hIcon[]);
void   set_iconPallet(int &hImg);
void   make_iconDot(int hImg, char (*img)[31], int num);
void   make_icon(int hIcon[]);
void   set_msgbox(int style, char *title="Message");
int    msgbox(LPSTR pform, ...);
void   print(int x, int y, LPSTR pform, ...);
 
 
//-----------------------------------------------------------------------------
// グローバル変数
//-----------------------------------------------------------------------------
SDot  g_dot;
UINT  g_White;
UINT  g_Blue;
UINT  g_Gray;
UINT  g_Black;
UINT  g_Yellow;
UINT  g_strColor;   // 関数 print の文字の色
UINT  g_bakColor;   // 関数 print の文字の背景色
UINT  g_msgStyle;
char *g_msgTitle;
 
 
//-----------------------------------------------------------------
// アイコン
//-----------------------------------------------------------------
char dot_e0[30][31]={
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
"b   b   b   b   b   b   b   b ",
"b   b   b   b   b   b   b   b ",
"b   b   b  gb   b   b   b   b ",
"bbbbbbbbbbbbggbbbbbbbbbbbbbbbb",
"b   b   b   bgggb   b   b   b ",
"b   b   b   b gggg  b   b   b ",
"b   b   b   b  gggggb   b   b ",
"bbbbbbbbbbbbbbbbggggggbbbbbbbb",
"b   b   b   b   bgggggggb   b ",
"b   b   b   b   b ggggggggg b ",
"b   b   b   b   b  gggg b   b ",
"bbbbbbbbbbbbbbbbbbbbgggbbbbbbb",
"b   b   b   b   b   bgg b   b ",
"b   b   b   b   b   b g b   b ",
"b   b ggggggg   b   b   b   b ",
"bbbbbbbbbgbbbbbbbbbbbbbbbbbbbb",
"b   g   bg  b g b   b   b   b ",
"b   g   bg  b g b   b   b   b ",
"b   g   b   b g b   b   b   b ",
"bbbbggggbbbggggbbbbbbbbbbbbbbb",
"b   g   b   b g b   b   b   b ",
"b   g   bg  b g b   b   b   b ",
"b   g   bg  b g b   b   b   b ",
"bbbbbbbbbgbbbbbbbbbbbbbbbbbbbb",
"b   b ggggggg   b   b   b   b ",
"b   b   b   b   b   b   b   b ",
"b   b   b   b   b   b   b   b ",
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
"b   b   b   b   b   b   b   b "
};
 
//------------------------------------------------------------------
char dot_e1[30][31]={
" w w  bb    w w w w w w w w w ",
"w      bbb                   w",
"        bbbb                  ",
"w        bbbbb               w",
"          bbbbbb              ",
"w          bbbbbbb           w",
"   gg       bbbbbbbb          ",
"w   ggg      bbbbbbbbb       w",
"     gggg     bbbbbbbbbb      ",
"w     ggggg    bbbbbbbbbbb   w",
"       gggggg   bbbbbbbbbbbb  ",
"        ggggggg  bbbbbbbbbbbbb",
"rr       gggggggg bbbbbb      ",
" rrr      gggggggggbbbbb      ",
"  rrrr     ggggggggggbbb     w",
"   rrrrr    gggggggggggb      ",
"w   rrrrrr   gggggggggggg     ",
"     rrrrrrr  ggggggggggggg  w",
"w     rrrrrrrr ggggggg        ",
"       rrrrrrrrrggggg         ",
"w       rrrrrrrrrrggg        w",
"         rrrrrrrrrrrg         ",
"w         rrrrrrrrrrrr        ",
"           rrrrrrrrrrrrr     w",
"w           rrrrrr            ",
"             rrrrr            ",
"w             rrrr           w",
"               rrr            ",
"w               rr           w",
" w w w w w w w   r  w w w w w "
};
 
//------------------------------------------------------------------
char dot_e2[30][31]={
"  b  b  b  b  b  b            ",
"  b  b  b  b  b  b            ",
"bbbbbbbbbbbbbbbbbbbb          ",
"  b  b  b  b  b  b            ",
"  b  b  b  b  b  b            ",
"bbbbbbbrbbrbbrbbrbbr  r       ",
"  b  b rb rb rb rb r  r       ",
"  b  rrrrrrrrrrrrrrrrrrrr     ",
"bbbbbbbrbbrbbrbbrbbr  r       ",
"  b  b rb rb rb rb r  r       ",
"  b  rrrrrrrgrrgrrgrrgrrg  g  ",
"bbbbbbbrbbrbgrbgrbgr gr g  g  ",
"  b  b rb gggggggggggggggggggg",
"  b  rrrrrrrgrrgrrgrrgrrg  g  ",
"bbbbbbbrbbrbgrbgrbgr gr g  g  ",
"  b  b rb gggggggggggggggggggg",
"  b  rrrrrrrgrrgrrgrrgrrg  g  ",
"bbbbbbbrbbrbgrbgrbgr gr g  g  ",
"  b  b rb gggggggggggggggggggg",
"  b  rrrrrrrgrrgrrgrrgrrg  g  ",
"       r  r gr gr gr gr g  g  ",
"       r  gggggggggggggggggggg",
"     rrrrrrrgrrgrrgrrgrrg  g  ",
"       r  r gr gr gr gr g  g  ",
"       r  gggggggggggggggggggg",
"            g  g  g  g  g  g  ",
"            g  g  g  g  g  g  ",
"          gggggggggggggggggggg",
"            g  g  g  g  g  g  ",
"            g  g  g  g  g  g  "
};
 
//------------------------------------------------------------------
char dot_e3[30][31]={
" wwwwwwwwwwwwwwwwwwwwwwwwwwww ",
"w                            w",
"w  gggggggggggggggggggggggg  w",
"w  gg ggggg  ggg   gg   ggg  w",
"w  gg gggg gg gg g gg gg gg  w",
"w  gg gggg gg g ggg g gg gg  w",
"w  gg gggg gg g     g gg gg  w",
"w  gg    gg  gg ggg g   ggg w ",
"w  gggggggggggggggggggggggg w ",
"w                            w",
"w                            w",
"w            wwww            w",
"w           w    w           w",
"w          w      w          w",
"w          w      w          w",
"w          w      w          w",
"w          w      w ww       w",
"w           w    w  ww       w",
"w            wwww            w",
"w                            w",
"w                            w",
"w             ww             w",
"w            w  w            w",
"w            w  w            w",
"w            w  w            w",
"w            w  w            w",
"w            w  w            w",
"w             ww             w",
"w                            w",
" wwwwwwwwwwwwwwwwwwwwwwwwwwww "
};
 
//------------------------------------------------------------------
char dot_e4[30][31]={
" w w w w w w w w w w          ",
"w                   w         ",
"   wwwwwwwwwwwwwww            ",
"w  ww w w w w w w w w w       ",
"   w                   w      ",
"w     wwwwwwwwwwwwwww         ",
"   w  ww w w w w w w w w w    ",
"w     w                   w   ",
"   w     wwwwwwwwwwwwwww      ",
"w     w  wwwwwwwwwwwwwwwwwwwww",
"   w     w                   w",
"w     w  w  wwwwwwwwwwwwwww  w",
"   w     w  wwwwwwwwwwwwwww  w",
"w     w  w  wwwwwwwwwwwwwww  w",
"   w     w                  w ",
"w     w  w                   w",
"   w     w        www        w",
"w     w  w       w   w       w",
"   w     w      w     w      w",
"w     w  w      w     w      w",
" w w     w      w     w ww   w",
"      w  w       w   w  ww   w",
"   w     w        www        w",
"    w w  w                   w",
"         w         w         w",
"      w  w        w w        w",
"       w w        w w        w",
"         w        w w        w",
"         w        w w        w",
"          wwwwwwwwwwwwwwwwwww "
};
 
//------------------------------------------------------------------
char dot_e5[30][31]={
" wwwwwwwwwwwwwwwwwwwwwwwwwwww ",
"w                            w",
"w  yyyyyyyyyyyyyyyyyyyyyyyy  w",
"w  yy    yy   yy yy y    yy  w",
"w  yy yyyy yyy y yy y yyyyy  w",
"w  yy    y     y yy y    yy  w",
"w  yyyyy y yyy y yy y yyyyy  w",
"w  yy    y yyy yy  yy    yy w ",
"w  yyyyyyyyyyyyyyyyyyyyyyyy w ",
"w                            w",
"w                            w",
"w            wwww            w",
"w           w    w           w",
"w          w      w          w",
"w          w      w          w",
"w          w      w          w",
"w          w      w ww       w",
"w           w    w  ww       w",
"w            wwww            w",
"w                            w",
"w                            w",
"w             ww             w",
"w            w  w            w",
"w            w  w            w",
"w            w  w            w",
"w            w  w            w",
"w            w  w            w",
"w             ww             w",
"w                            w",
" wwwwwwwwwwwwwwwwwwwwwwwwwwww "
};
 
//------------------------------------------------------------------
char dot_e6[30][31]={
" cccccccccccccccccccccccccccc ",
"cccccccccccccccccccccccccccccc",
"cccccccccccccccccccccccccccccc",
"cccccccccccccccccccccccccccccc",
"cccccccccccccccccccccccccccccc",
"cccccccccccccccccccccccccccccc",
"cccccccccc          cccccccccc",
"ccccccc                ccccccc",
"ccccc                    ccccc",
"cccc                      cccc",
"ccc                        ccc",
"cc                          cc",
"                              ",
"                              ",
"c                            c",
"cc                          cc",
"ccc                        ccc",
"cccc      cccccccccc      cccc",
"ccccc  cccccccccccccccc  ccccc",
"cccccccccccccccccccccc  cccccc",
"ccccccccccccccccccccc  ccccccc",
"cccccccccccccccccccc  cccccccc",
"cccccccccccccccccc   ccccccccc",
"ccccccccccccccccc   cccccccccc",
"cccccccccccccccc    cccccccccc",
"ccccccccccccccc    ccccccccccc",
"cccccccccccccc    cccccccccccc",
"ccccccccccccc    ccccccccccccc",
"cccccccccccc    cccccccccccccc",
" cccccccccc    cccccccccccccc "
};
 
//------------------------------------------------------------------
char dot_e7[30][31]={
"bbbbbbbbb  bb     bbbbbbbbbbbb",
"                              ",
"cccccccc   cc     cccccccccccc",
"ccccccccc  cc     cccccccccccc",
"cc     cc  cc     cc    cc    ",
"                              ",
"gggggggg   gg     gggggggggggg",
"ggggggggg  gg     gggggggggggg",
"gg     gg  gg     gg    gg    ",
"gg     gg  gg     gg          ",
"gg     gg  gg     gg          ",
"                              ",
"yyyyyyyy   yy     yyyyyyyyyyyy",
"yy     yy  yy     yyyyyyyyyyyy",
"yy      y  yy     yy    yy    ",
"yy      y  yy     yy    yy    ",
"yy      y  yy     yy    yy    ",
"yyyyyyyyy  yy     yy    yy    ",
"yyyyyyyy   yy     yy    yy    ",
"                              ",
"wwwwwwww   ww     wwwwwwwwwwww",
"wwwwwwww   ww     wwwwwwwwwwww",
"w       w  ww     ww    ww    ",
"w       w  ww     ww    ww    ",
"w       w  ww     ww    ww    ",
"wwwwwwwww  ww     ww    ww    ",
"wwwwwwww   ww     ww    ww    ",
"ww         ww     ww    ww    ",
"ww         wwwwwwwww    ww    ",
"ww          wwwwwww     ww    "
};
 
//------------------------------------------------------------------
char dot_e8[30][31]={
"      r r r r r r r r r r r r ",
"     r r r r r r r r r r r r r",
"      r r r r r r r r r r r r ",
"     r r r r r r r r r r r r r",
"      r r r r r r r r r r r r ",
"     r r r r r r r r r r r r r",
"      r r r r r r r r r r r r ",
"     r r r r r r r r r r r r r",
"bbbbb w w w w w w w w w w r r ",
"b   br r r r r r r r r r r r r",
"b   b r w r w r w r w r w r r ",
"b   br r r r r r r r r r r r r",
"bbbbb w w w w w w w w w w r r ",
"b   br r r r r r r r r r r r r",
"b   b r w r w r w r w r w r r ",
"b   br r r r r r r r r r r r r",
"bbbbb w w w w w w w w w w r r ",
"b   br r r r r r r r r r r r r",
"b   b r w r w r w r w r w r r ",
"b   br r r r r r r r r r r r r",
"bbbbb r w r w r w r w r w r r ",
"bbbbbbbbbbbbbbbbbbbbbbbbb     ",
"b   b   b   b   b   b   b     ",
"b   b   b   b   b   b   b     ",
"b   b   b   b   b   b   b     ",
"bbbbbbbbbbbbbbbbbbbbbbbbb     ",
"b   b   b   b   b   b   b     ",
"b   b   b   b   b   b   b     ",
"b   b   b   b   b   b   b     ",
"bbbbbbbbbbbbbbbbbbbbbbbbb     "
};
 
//------------------------------------------------------------------
char dot_e9[30][31]={
" wwwwwwwwwwwwwwwwwwwwwwwwwwww ",
"w                            w",
"w  rrrrrrrrrrrrrrrrrrrrrrrr  w",
"w  rrrwwwwrrwrrrrwwwwwwwwrr  w",
"w  rrwrrrrwrwrrrrwrrrwrrrrr  w",
"w  rrwrrrrwrwrrrrwrrrwrrrrr  w",
"w  rrwrrrrwrwrrrrwrrrwrrrrr  w",
"w  rrrwwwwrrrwwwwrrrrwrrrrr w ",
"w  rrrrrrrrrrrrrrrrrrrrrrrr w ",
"w                            w",
"w                            w",
"w            wwww            w",
"w           w    w           w",
"w          w      w          w",
"w          w      w          w",
"w          w      w          w",
"w          w      w ww       w",
"w           w    w  ww       w",
"w            wwww            w",
"w                            w",
"w                            w",
"w             ww             w",
"w            w  w            w",
"w            w  w            w",
"w            w  w            w",
"w            w  w            w",
"w            w  w            w",
"w             ww             w",
"w                            w",
" wwwwwwwwwwwwwwwwwwwwwwwwwwww "
};
 
//------------------------------------------------------------------
char dot_e10[30][31]={
"    wwwwwwwwwwwwwwwwwwwwww    ",
"   w                      w   ",
"   w  w w w w w w w w w   w   ",
"   w   w w w w w w w w    www ",
" www  w w w w w w w w w   w ww",
"ww w                     w w w",
"w ww                     ww ww",
"ww w                      ww w",
"w ww         wwww         w ww",
"ww w        w    w        ww w",
"w ww       w      w       w ww",
"ww w       w      w       ww w",
"wwwwwwwwwwwwwwwwwwwwwwwwwwwwww",
"wwwwwwwwwwwwwwwwwwwwwwwwwwwwww",
"wwwwwwwwwwwwwwwwwwwwwwwwwwwwww",
"wwwwwwwwwwwwwwwwwwwwwwwwwwwwww",
"wwrrrrrrrwwrrwwwwrrwwrrrrrwwww",
"wwrrrrrrrwwrrrwwwrrwwrrrrrrwww",
"wwrrwwwwwwwrrrwwwrrwwrrwwrrrww",
"wwrrwwwwwwwrrrrwwrrwwrrwwwrrww",
"wwrrwwwwwwwrrwrwwrrwwrrwwwrrww",
"wwrrrrrrrwwrrwrrwrrwwrrwwwrrww",
"wwrrrrrrrwwrrwwrwrrwwrrwwwrrww",
"wwrrwwwwwwwrrwwrrrrwwrrwwwrrww",
"wwrrwwwwwwwrrwwwrrrwwrrwwwrrww",
"wwrrwwwwwwwrrwwwrrrwwrrwwrrrww",
"wwrrrrrrrwwrrwwwrrrwwrrrrrrwww",
"wwrrrrrrrwwrrwwwwrrwwrrrrrwwww",
"wwwwwwwwwwwwwwwwwwwwwwwwwwwwww",
"wwwwwwwwwwwwwwwwwwwwwwwwwwwwww"
};
 
//------------------------------------------------------------------
char dot_e11[30][31]={
"         mmmmmmm              ",
"        mmmmmmm               ",
"       mmmmmmm                ",
"       mmmmmmm                ",
"       mmmmmmm                ",
"      wwwwwwwww               ",
"     w         w              ",
"     w         w              ",
"  wwwwwwwwwwwwwwwww           ",
" w   wmw           w          ",
" w   mwm           w          ",
" wwwwwmwwwwwwwwwwwww          ",
" wwwwmwmwwwwwwwwwwww          ",
" wmmmwmwmmmmmmmmmmmw          ",
" wmmmmwmmmmmmmmmmmmw          ",
" wmmmwmwmmmmmmmmmmmw          ",
" wmmmmwmmmmmmmmmmmmw          ",
" wmmmwmwmmmmmmmmmmmw          ",
" wmmmmwmmmmmmmmmmmmw          ",
" wmmmwmwmmmmmmmmmmmw          ",
" wmmmmwmmmmmmmmmmmmw          ",
" wwwwwwwwwwwwwwwwwww          ",
" wwwwwwwwwwwwwwwwwww          ",
"w    wmw            w         ",
"w    mwm            w         ",
"w    wmw            w         ",
"wwwwwmwmwwwwwwwwwwwww         ",
"w                   w         ",
"w                   w         ",
"wwwwwwwwwwwwwwwwwwwww         "
};
 
//------------------------------------------------------------------
char dot_e12[30][31]={
"                              ",
"                              ",
"   wwwwwwwwwwwwwww            ",
"   w             w            ",
"   w             w            ",
"   wwwwwwwwwwwwwww            ",
"     w         w              ",
"     w         w              ",
"  wwwwwwwwwwwwwwwww           ",
" w   wmw           w          ",
" w   mwm           w          ",
" wwwwwmwwwwwwwwwwwww          ",
" wwwwmwmwwwwwwwwwwww          ",
" wmmmwmwmmmmmmmmmmmw          ",
" wmmmmwmmmmmmmmmmmmw          ",
" wmmmwmwmmmmmmmmmmmw          ",
" wmmmmwmmmmmmmmmmmmw          ",
" wmmmwmwmmmmmmmmmmmw          ",
" wmmmmwmmmmmmmmmmmmw          ",
" wmmmwmwmmmmmmmmmmmw          ",
" wmmmmwmmmmmmmmmmmmw          ",
" wwwwwwwwwwwwwwwwwww          ",
" wwwwwwwwwwwwwwwwwww          ",
"w    wmw            w         ",
"w    mwm            w         ",
"w    wmw            w         ",
"wwwwwmwmwwwwwwwwwwwww         ",
"w                   w         ",
"w                   w         ",
"wwwwwwwwwwwwwwwwwwwww         "
};
 
//-----------------------------------------------------------------------------
// エントリーポイント
//-----------------------------------------------------------------------------
int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
{
    UINT aColor[MAX_COLOR];     // ドット絵用のパレット
    int  hIcon[MAX_ICON];       // アイコンのグラフィックハンドル
    int  x, y;
    int  Mouse;
   
    ChangeWindowMode(TRUE);
    SetGraphMode( 800 , 600 , 32 ) ;
    if(DxLib_Init()==-1) {return -1;}
    ChangeFont( "MS ゴシック" ) ;
    SetFontSize( 16 ) ;
    SetFontThickness( 1 );              // 文字の太さを1ドットにする
    SetDrawScreen( DX_SCREEN_BACK );
 
    g_White    = GetColor(WHITE);
    g_Blue     = GetColor(BLUE);
    g_Gray     = GetColor(GRAY);
    g_Black    = GetColor(BLACK);
    g_Yellow   = GetColor(YELLOW);
    g_strColor = GetColor(WHITE);
    g_bakColor = GetColor(BLACK);
   
    g_dot.L_x   = 230+19*20;    // 左ボタン(L)の色のX座標
    g_dot.R_x   = 230;          // 右ボタン(R)の色のX座標
    g_dot.L_num = 19;           // 左ボタンの色(白)
    g_dot.R_num = 0;            // 右ボタンの色(黒)
    g_dot.L_color = g_White;
    g_dot.R_color = g_Black;
    g_dot.mesh_nColor = 16;     // メッシュの色(青)
    g_dot.eState = STATE_MAIN;
 
    set_msgbox(MB_YESNO);
    set_pallet(aColor);
    strcpy( &g_dot.alpha[0], " RGYBMCunscodrgybmcw"); // 変換用アルファベット
    make_icon(hIcon);               // アイコンを作成
   
    while( !ScreenFlip() && !ProcessMessage() /*&& !ClearDrawScreen()*/ )
    {
        Mouse = GetMouseInput();    // マウスの入力状態取得
        GetMousePoint( &x, &y );    // マウスの座標取得
 
        put_disp(aColor, hIcon);
 
        switch(g_dot.eState ) {
        case STATE_MAIN:        // メイン処理
            g_dot.eState = main_dot(x, y, Mouse, aColor);
            break;
 
        case STATE_MESH:        // メッシュの色を変更する
            g_dot.eState = put_mesh(aColor, hIcon);
            break;
 
        case STATE_PUT_ALPHA:   // アルファベットに変換して表示
            g_dot.eState = put_alpha(aColor, hIcon);
            break;
 
        case STATE_LOAD:        //
            //g_dot.eState = load(aColor);
            break;
 
        case STATE_SAVE:        // セーブ
            g_dot.eState = save(aColor);
            break;
 
        case STATE_CLEAR:       // 画面のクリア
            g_dot.eState = cls(aColor);
            break;
 
        case STATE_END: //
            if(IDYES==msgbox("終了しますか?")){ goto end;}
            g_dot.eState = STATE_MAIN;
            break;
        }
        print(40, 32*16, "%d, %d  ", x, y);  // マウス座標を表示
    }
end:
    DxLib_End();
    return 0;
}
 
//-----------------------------------------------------------------------------
// メイン処理
//-----------------------------------------------------------------------------
EState main_dot(int x, int y, int Mouse, UINT aColor[])
{
    if( Mouse & MOUSE_INPUT_RIGHT ){    // マウスの右ボタンが押された
 
        if((x>=40 && x<640+40) && (y>=80 && y<430-30)){
            draw_dot(x, y, 2);              // ドット絵を描く
            return STATE_MAIN;              // ロード
        }
        if((x>225 && x<625) && (y>5 && y<40)){
            select_color(x, aColor, 2);     // 色を選択する
            return STATE_MAIN;              // ロード
        }
    }
   
    if( Mouse & MOUSE_INPUT_LEFT ){         // マウスの左ボタンが押された
       
        if((x>=40 && x<640+40) && (y>=80 && y<430-30)){
            draw_dot(x, y, 1);              // ドット絵を描く
            return STATE_MAIN;
        }
        if((x>225 && x<625) && (y>5 && y<40)){
            select_color(x, aColor, 1);     // 色を選択する
            return STATE_MAIN;              // ロード
        }
        if((x>8*2 && x<8*9) && (y>5 && y<35)){
            return STATE_MAIN;              // ロード
        }
        if((x>8*9 && x<8*19) && (y>5 && y<35)){
            return STATE_SAVE;              // セーブ
        }
        if((x>40*1 && x<40*2) && (y>16*28 && y<16*30)){
            return STATE_MAIN;              // マウスの形を変える
        }
        if((x>40*2 && x<40*3) && (y>16*28 && y<16*30)){
            return STATE_MAIN;              // マウスの色を変える
        }
        if((x>40*3 && x<40*4) && (y>16*28 && y<16*30)){
            return STATE_MESH;              // メッシュの色を変える
        }
        if((x>40*4 && x<40*5) && (y>16*28 && y<16*30)){
            return STATE_MAIN;              //
        }
        if((x>40*5 && x<40*6) && (y>16*28 && y<16*30)){
            return STATE_MAIN;              //
        }
        if((x>40*6 && x<40*7) && (y>16*28 && y<16*30)){
            return STATE_SAVE;              // セーブ
        }
        if((x>40*7 && x<40*8) && (y>16*28 && y<16*30)){
            return STATE_CLEAR;             // 消去
        }
        if((x>40*8 && x<40*9) && (y>16*28 && y<16*30)){
            return STATE_PUT_ALPHA;         // アルファベットに変換して表示する
        }
        if((x>40*9 && x<40*10) && (y>16*28 && y<16*30)){
            return STATE_MAIN;              //
        }
        if((x>40*10 && x<40*11) && (y>16*28 && y<16*30)){
            return STATE_MAIN;              //
        }
        if((x>40*11 && x<40*12) && (y>16*28 && y<16*30)){
            return STATE_END;               // 終了
        }
    }
    return STATE_MAIN;
}
 
//-----------------------------------------------------------------
// マウスによる色の選択
//-----------------------------------------------------------------
EState select_color(int x, UINT aColor[], int LR)
{
    int n;
 
    n = (x-225)/20;             // 選択色をセット
    x = n * 20 + 230;           // 座標を計算
 
    if(LR==1){                      // 左ボタン
        g_dot.L_color = aColor[n];
        g_dot.L_x = x;              // x座標を保存
        g_dot.L_num = (UCHAR)n;     // 色の番号
    }
    else {                          // 右ボタン
        g_dot.R_color = aColor[n];
        g_dot.R_x = x;              // x座標を保存
        g_dot.R_num = (UCHAR)n;     // 色の番号
    }
    return STATE_MAIN;
}
 
//-----------------------------------------------------------------------------
// ドット絵の色データをアルファベットにして表示
//-----------------------------------------------------------------------------
EState put_alpha(UINT aColor[], int hIcon[])
{
    int   i, j;
    UCHAR n;
   
    ClearDrawScreen();
    DrawString(16*2, 16, "アルファベットに変換しました。", g_White);
 
    for(j=0; j<MESH_H ; j++){
        for(i=0; i<MESH_W ; i++){
            n = g_dot.masu[j][i];
            DrawFormatString(i*12+15, j*14+45, aColor[n], "%c", g_dot.alpha[n]);
        }
    }
    ScreenFlip();
    WaitKey();              // キー入力待ち
    ClearDrawScreen();
    put_dot(aColor);
    put_disp(aColor, hIcon);
    ScreenFlip();
    WaitTimer(200);
   
    return STATE_MAIN;
}
 
//-----------------------------------------------------------------------------
// メッシュの色を変える
//-----------------------------------------------------------------------------
EState put_mesh(UINT aColor[], int hIcon[])
{
    g_dot.mesh_nColor++;
   
    if(g_dot.mesh_nColor >= MAX_PALLET){
        g_dot.mesh_nColor = 0;
    }
    put_disp(aColor, hIcon);
    ScreenFlip();
    WaitTimer(200);
   
    return STATE_MAIN;
}
 
//-----------------------------------------------------------------------------
// 画像の消去
//-----------------------------------------------------------------------------
EState cls(UINT aColor[])
{
    int x, y;
   
   
    if(IDNO==msgbox("画像を消去しますか?")){
        return STATE_MAIN;
    }
   
    for(y=0 ; y<MESH_H ; y++)
        for(x=0; x<MESH_W ; x++){
            g_dot.masu[y][x] = 0 ;{ // 消去
        }
    }
    put_dot(aColor);                // 消去したのを表示
    ScreenFlip();
    WaitTimer(200);
 
    return STATE_MAIN;
}
 
//-----------------------------------------------------------------------------
// ファイルに保存
//-----------------------------------------------------------------------------
EState save(UINT aColor[])
{
    int  i, j, w, h;
    static int  HH=32, WW=32;
   
    ClearDrawScreen();
 
    DrawFormatString( 16 , 16 , g_White, "横ドット数 = %d (1~64)" ,  WW) ;
    w = KeyInputNumber( 16*13 , 16 , MESH_W , 1 , TRUE ) ;
    if (w==MESH_W+1) {  // [ESC]を押された場合
        ClearDrawScreen(); put_dot(aColor);
        return STATE_MAIN;
    }
    else { WW=w; }
 
    DrawFormatString( 16 , 16*3 , g_White, "縦ドット数 = %d (1~32)",  HH) ;
    h = KeyInputNumber( 16*13 , 16*3 , MESH_H , 1 , TRUE ) ;
    if (h==MESH_H+1) {  // [ESC]を押された場合
        ClearDrawScreen(); put_dot(aColor);
        return STATE_MAIN;
    }
    else { HH=h; }
   
    for(j=0; j<h ; j++){
        for(i=0; i<w ; i++){
            g_dot.moji[j][i+1] = g_dot.alpha[g_dot.masu[j][i]];
        }
        g_dot.moji[j][  0]='"';
        g_dot.moji[j][w+1]='"';
        g_dot.moji[j][w+2]=',';
        g_dot.moji[j][w+3]='\n';
        g_dot.moji[j][w+4]='\0';
    }
    g_dot.moji[j-1][w+2]='\0';
 
    FILE *p = fopen("ドット絵.txt", "a");
    char szW[128];
    char szH[128];
    char str[256];
 
    memset(str, 0, 256);
    w++;                    // NULL文字用に1個増やす
    itoa(h, szH, 10);       // 配列の要素数
    itoa(w, szW, 10);       // 配列の要素数
   
    strcat(str, "char dot_e[" );
    strcat(str, szH);
    strcat(str, "][");
    strcat(str, szW);
    strcat(str, "]={\n");
 
    fputs("//------------------------------------------------------------------\n", p);
    fputs(str, p);
    for(i=0; i<h ; i++){
        fputs(&g_dot.moji[i][0], p);
    }
    fputs("\n};\n\n", p);
   
    fclose(p);
 
    DrawString( 16 , 16*5 , "ドット絵.txt に保存しました。" , g_Yellow ) ;
    ScreenFlip();
   
    WaitKey();
    ClearDrawScreen();
    put_dot(aColor);
    WaitTimer(200);
   
    return STATE_MAIN;
}
 
//-----------------------------------------------------------------
// ドット絵用のパレットにスタティックカラーをセット
//-----------------------------------------------------------------
void set_pallet(UINT aColor[])
{
    aColor[ 0] = GetColor(BLACK);
    aColor[ 1] = GetColor(D_RED);
    aColor[ 2] = GetColor(D_GREEN);
    aColor[ 3] = GetColor(D_YELLOW);
    aColor[ 4] = GetColor(D_BLUE);
    aColor[ 5] = GetColor(D_MAGENTA);
    aColor[ 6] = GetColor(D_CYAN);
    aColor[ 7] = GetColor(GRAY);
    aColor[ 8] = GetColor(M_GREEN);
    aColor[ 9] = GetColor(S_BLUE);
 
    aColor[10] = GetColor(CREAM);
    aColor[11] = GetColor(M_GRAY);
    aColor[12] = GetColor(D_GRAY);
    aColor[13] = GetColor(RED);
    aColor[14] = GetColor(GREEN);
    aColor[15] = GetColor(YELLOW);
    aColor[16] = GetColor(BLUE);
    aColor[17] = GetColor(MAGENTA);
    aColor[18] = GetColor(CYAN);
    aColor[19] = GetColor(WHITE);
 
    aColor[20] = GetColor(MD_RED);
    aColor[21] = GetColor(MD_GREEN);
    aColor[22] = GetColor(MD_YELLOW);
    aColor[23] = GetColor(MD_BLUE);
    aColor[24] = GetColor(MD_MAGENTA);
    aColor[25] = GetColor(MD_CYAN);
    aColor[26] = GetColor(L_BLUE);
}
 
//-----------------------------------------------------------------------------
// ドット絵用のパレットを表示
//-----------------------------------------------------------------------------
void put_pallet(UINT aColor[])
{
    for(int i=0 ; i<MAX_PALLET ; i++){
        DrawBox(224+(20*i), 7, 243+(20*i), 41, aColor[i], TRUE);    // 色を表示
    }
    DrawBox(222, 5, 245+(20*19), 43, g_Gray, FALSE);            // 色の枠
 
    // 色選択時、左ボタン(L)か、右ボタン(R)かを表示
    DrawBox(g_dot.L_x-1, 14, g_dot.L_x+8, 14+16, g_White, TRUE);
    DrawBox(g_dot.R_x-1, 14, g_dot.R_x+8, 14+16, g_White, TRUE);
    DrawString(g_dot.L_x, 14, "L", g_Black);
    DrawString(g_dot.R_x, 14, "R", g_Black);
}
 
//-----------------------------------------------------------------------------
// ドット絵の表示
//-----------------------------------------------------------------------------
void put_dot(UINT aColor[])
{
    int x, y;
   
    for(y=0; y<MESH_H ; y++){
        for(x=0; x<MESH_W ; x++){
            DrawBox(x*10+40+1, y*10+80+1, x*10+40+10, y*10+80+10, aColor[g_dot.masu[y][x]], TRUE);  // マスを塗る
        }
    }
   
    for(y=0; y<MESH_H ; y++){
        for(x=0; x<MESH_W ; x++){
            DrawPixel(x+148+4, y+8, aColor[g_dot.masu[y][x]]);  // 実寸で表示
        }
    }
}
 
//-----------------------------------------------------------------
// ディスプレイ画面
//-----------------------------------------------------------------
void put_disp(UINT aColor[], int hIcon[])
{
    int  x2, y2;
 
    DrawBox(8*2, 5, 140, 35, g_Gray, FALSE);        // メニュー枠を表示
    DrawString(8*4, 12, "読込   保存", g_White);    // メニューを表示
 
    //DrawBox(150, 5, 213, 45, g_Gray, FALSE);  // 実寸用の枠を表示
 
    put_pallet(aColor);     // パレットを表示
    put_icon(hIcon);        // アイコンを表示
 
    //------ メッシュ(縦と横の線)----------------
 
    for(y2=80 ; y2<=420-20 ; y2+=10){               // 10ドット単位の横線
        DrawLine(40, y2, 640+40, y2, aColor[g_dot.mesh_nColor]);
    }
    for(y2=80 ; y2<=430-20 ; y2+=50){               // 50ドット単位の横線
        DrawLine(30, y2, 650+40, y2, aColor[g_dot.mesh_nColor]);
    }
 
    for(x2=40 ; x2<=640+40 ; x2+=10){               // 10ドット単位の縦線
        DrawLine(x2, 80, x2, 430-30, aColor[g_dot.mesh_nColor]);
    }
    for(x2=40 ; x2<=640+40 ; x2+=50){               // 50ドット単位の縦線
        DrawLine(x2, 70, x2, 440-30, aColor[g_dot.mesh_nColor]);
    }
 
    for(x2=35; x2<=640 ; x2+=100){
        DrawFormatString(x2, 50, g_White, "%d", x2/10-3);   // 横ドット数を表示
    }
    for(y2=70; y2<=430 ; y2+=100){
        DrawFormatString(10, y2, g_White , "%d", y2/10-7);  // 縦ドット数を表示
    }
}
 
//-----------------------------------------------------------------------------
// マスを塗る(ドット絵作成)
//-----------------------------------------------------------------------------
void draw_dot(int x,int y, int LR)
{
    int  mx, my;
 
    mx = x/10;          // 配列に入れるため。
    my = y/10;
    x  = x/10*10;       // 10ドット単位にするため端数を切り捨てる
    y  = y/10*10;
 
    if(LR==1){  // 左ボタン
        DrawBox(x+1, y+1, x+10, y+10, g_dot.L_color, TRUE); // マスを塗る
        DrawPixel(mx+148, my, g_dot.L_color);
        g_dot.masu[my-8][mx-4] = g_dot.L_num;
    }
    else {      // 右ボタン
        DrawBox(x+1, y+1, x+10, y+10, g_dot.R_color, TRUE); // マスを塗る
        DrawPixel(mx+148, my, g_dot.R_color);
        g_dot.masu[my-8][mx-4] = g_dot.R_num;
    }
    print(8*6, 16*26, "(%2d,%2d)", mx-3, my-7); // マスの座標を表示
}
 
//-----------------------------------------------------------------------------
// アイコンを表示
//-----------------------------------------------------------------------------
void put_icon(int hIcon[])
{
    DrawGraph( 40*1,  16*28, hIcon[0],  FALSE );
    DrawGraph( 40*2,  16*28, hIcon[1],  FALSE );
    DrawGraph( 40*3,  16*28, hIcon[2],  FALSE );
    DrawGraph( 40*4,  16*28, hIcon[3],  FALSE );
    DrawGraph( 40*5,  16*28, hIcon[4],  FALSE );
    DrawGraph( 40*6,  16*28, hIcon[5],  FALSE );
    DrawGraph( 40*7,  16*28, hIcon[6],  FALSE );
    DrawGraph( 40*8,  16*28, hIcon[7],  FALSE );
    DrawGraph( 40*9,  16*28, hIcon[8],  FALSE );
    DrawGraph( 40*10, 16*28, hIcon[9],  FALSE );
    DrawGraph( 40*11, 16*28, hIcon[10], FALSE );
    DrawGraph( 40*12, 16*28, hIcon[11], FALSE );
}
 
//-----------------------------------------------------------------------------
// アイコンを作る
//-----------------------------------------------------------------------------
void make_icon(int hIcon[])
{
    int hImg;           // パレット画像のハンドル
 
    hImg = MakePAL8ColorSoftImage( 30, 30 * MAX_ICON );// 空のパレット画像を作成する
    set_iconPallet(hImg);   // パレットに色をセットする
 
    //アイコンのドット絵を描く
    make_iconDot(hImg, dot_e0,  0);
    make_iconDot(hImg, dot_e1,  1);
    make_iconDot(hImg, dot_e2,  2);
    make_iconDot(hImg, dot_e3,  3);
    make_iconDot(hImg, dot_e4,  4);
    make_iconDot(hImg, dot_e5,  5);
    make_iconDot(hImg, dot_e6,  6);
    make_iconDot(hImg, dot_e7,  7);
    make_iconDot(hImg, dot_e8,  8);
    make_iconDot(hImg, dot_e9,  9);
    make_iconDot(hImg, dot_e10, 10);
    make_iconDot(hImg, dot_e11, 11);
    make_iconDot(hImg, dot_e12, 12);
 
    // 分割読み込み
    CreateDivGraphFromSoftImage(hImg, MAX_ICON, 1, MAX_ICON, 30, 30, hIcon);
    DeleteSoftImage( hImg ) ;   // 使い終わったら解放
}
 
//-----------------------------------------------------------------------------
// アイコンを描く
//-----------------------------------------------------------------------------
void make_iconDot(int hImg, char (*img)[31], int num)
{
    int x, y, y2, color;
 
    for(y2=0, y=30*num ; y<30*num+30 ; y++, y2++){
        for(x=0; x<30 ; x++){
            color=0;
            if(img[y2][x] == ' ') { color =  0; }
            if(img[y2][x] == 'R') { color =  1; }
            if(img[y2][x] == 'G') { color =  2; }
            if(img[y2][x] == 'Y') { color =  3; }
            if(img[y2][x] == 'B') { color =  4; }
            if(img[y2][x] == 'M') { color =  5; }
            if(img[y2][x] == 'C') { color =  6; }
            if(img[y2][x] == 'u') { color =  7; }
            if(img[y2][x] == 'n') { color =  8; }
            if(img[y2][x] == 's') { color =  9; }
            if(img[y2][x] == 'c') { color = 10; }
            if(img[y2][x] == 'o') { color = 11; }
            if(img[y2][x] == 'd') { color = 12; }
            if(img[y2][x] == 'r') { color = 13; }
            if(img[y2][x] == 'g') { color = 14; }
            if(img[y2][x] == 'y') { color = 15; }
            if(img[y2][x] == 'b') { color = 16; }
            if(img[y2][x] == 'm') { color = 17; }
            if(img[y2][x] == 'c') { color = 18; }
            if(img[y2][x] == 'w') { color = 19; }
 
            DrawPixelPalCodeSoftImage( hImg, x, y, color ) ;
        }
    }
}
 
//-----------------------------------------------------------------------------
// アイコン用のパレットに色をセットする
//-----------------------------------------------------------------------------
void set_iconPallet(int &hImg)
{
    SetPaletteSoftImage( hImg,  0, BLACK,     0 ) ;
    SetPaletteSoftImage( hImg,  1, D_RED,     0 ) ;
    SetPaletteSoftImage( hImg,  2, D_GREEN,   0 ) ;
    SetPaletteSoftImage( hImg,  3, D_YELLOW,  0 ) ;
    SetPaletteSoftImage( hImg,  4, D_BLUE,    0 ) ;
    SetPaletteSoftImage( hImg,  5, D_MAGENTA, 0 ) ;
    SetPaletteSoftImage( hImg,  6, D_CYAN,    0 ) ;
    SetPaletteSoftImage( hImg,  7, GRAY,      0 ) ;
    SetPaletteSoftImage( hImg,  8, M_GREEN,   0 ) ;
    SetPaletteSoftImage( hImg,  9, S_BLUE,    0 ) ;
 
    SetPaletteSoftImage( hImg, 10, CREAM,     0 ) ;
    SetPaletteSoftImage( hImg, 11, M_GRAY,    0 ) ;
    SetPaletteSoftImage( hImg, 12, D_GRAY,    0 ) ;
    SetPaletteSoftImage( hImg, 13, RED,       0 ) ;
    SetPaletteSoftImage( hImg, 14, GREEN,     0 ) ;
    SetPaletteSoftImage( hImg, 15, YELLOW,    0 ) ;
    SetPaletteSoftImage( hImg, 16, BLUE,      0 ) ;
    SetPaletteSoftImage( hImg, 17, MAGENTA,   0 ) ;
    SetPaletteSoftImage( hImg, 18, CYAN,      0 ) ;
    SetPaletteSoftImage( hImg, 19, WHITE,     0 ) ;
}
 
//-----------------------------------------------------------------
//  書式付きメッセージボックス
//-----------------------------------------------------------------
int msgbox(LPSTR pform, ...)
{
    va_list bp;
    char    msg[256];
 
    va_start(bp, pform);
    vsprintf(msg, pform, bp);
    va_end(bp);
 
    return MessageBox(NULL, msg, g_msgTitle, g_msgStyle);
}
 
//-----------------------------------------------------------------
//  メッセージボックスのスタイルとタイトルをセットする
//-----------------------------------------------------------------
void set_msgbox(int style, char *title)
{
    g_msgStyle = style;
    g_msgTitle = title;
}
 
//-----------------------------------------------------------------
//  書式付き文字出力
//-----------------------------------------------------------------
void print(int x, int y, LPSTR pform, ...)
{
    va_list bp;
    char    str[256];
    int     len;
 
    va_start(bp, pform);
    len = vsprintf(str, pform, bp);
    va_end(bp);
 
    DrawBox(x, y, x+len*8, y+16, g_bakColor, TRUE);
    DrawString(x, y, str, g_strColor);
}

Name: どぶろく
[URL]
プログラマー(30,434 ポイント)
Date: 2018年2月02日(金) 19:41
No: 18
(OFFLINE)

 Re: ぷるぷるプログラミング

それにしても誰も参加してこないなぁ。
自己紹介と雑談のトピックでも作ろうかな。

ドット絵エディタの方は、まだ、保存したデータを読み込むことは出来てません。
考えとしては、ファイルを読み込んで、メモリ上であれこれするんですね。
そもそも、追加書き込みしてるのがヤバイのかなぁ?
まぁ、明後日の日曜日にでも考えようっと。

話は変わるが前回アップしたドット絵エディタの若干の訂正箇所を発見しました。
WinMain内で初期化している変換用アルファベットの中に小文字の c が2つ入っていました。

コード[C++]: 全て選択
1
strcpy( &g_dot.alpha[0], " RGYBMCunscodrgybmcw"); // 変換用アルファベット

これを下のように訂正します。

コード[C++]: 全て選択
1
strcpy( &g_dot.alpha[0], " RGYBMCunstodrgybmcw"); // 変換用アルファベット

最初に出てくる c を t にしただけ。

また、

コード[C++]: 全て選択
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
//-----------------------------------------------------------------------------
// アイコンを描く
//-----------------------------------------------------------------------------
void make_iconDot(int hImg, char (*img)[31], int num)
{
    int x, y, y2, color;
 
    for(y2=0, y=30*num ; y<30*num+30 ; y++, y2++){
        for(x=0; x<30 ; x++){
            color=0;
            if(img[y2][x] == ' ') { color =  0; }
            if(img[y2][x] == 'R') { color =  1; }
            if(img[y2][x] == 'G') { color =  2; }
            if(img[y2][x] == 'Y') { color =  3; }
            if(img[y2][x] == 'B') { color =  4; }
            if(img[y2][x] == 'M') { color =  5; }
            if(img[y2][x] == 'C') { color =  6; }
            if(img[y2][x] == 'u') { color =  7; }
            if(img[y2][x] == 'n') { color =  8; }
            if(img[y2][x] == 's') { color =  9; }
            if(img[y2][x] == 'c') { color = 10; }
            if(img[y2][x] == 'o') { color = 11; }
            if(img[y2][x] == 'd') { color = 12; }
            if(img[y2][x] == 'r') { color = 13; }
            if(img[y2][x] == 'g') { color = 14; }
            if(img[y2][x] == 'y') { color = 15; }
            if(img[y2][x] == 'b') { color = 16; }
            if(img[y2][x] == 'm') { color = 17; }
            if(img[y2][x] == 'c') { color = 18; }
            if(img[y2][x] == 'w') { color = 19; }
 
            DrawPixelPalCodeSoftImage( hImg, x, y, color ) ;
        }
    }
}

を以下のように訂正します。
これにより、変換用アルファベットのデータをそのまま使うことになり、いちいち変更する手間が省けます。

コード[C++]: 全て選択
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//-----------------------------------------------------------------------------
// アイコンを描く
//-----------------------------------------------------------------------------
void make_iconDot(int hImg, char (*img)[31], int num)
{
    int i, x, y, y2, color;
 
    for(y2=0, y=30*num ; y<30*num+30 ; y++, y2++){
        for(x=0; x<30 ; x++){
            color=0;
            for(i=0 ; i<MAX_PALLET; i++){
                if(img[y2][x] == g_dot.alpha[i]){   // 同じアルファベットなら
                    color = i;
                    break;
                }
            }
            DrawPixelPalCodeSoftImage( hImg, x, y, color ) ;
        }
    }
}

Name: どぶろく
[URL]
プログラマー(30,434 ポイント)
Date: 2018年2月06日(火) 18:25
No: 19
(OFFLINE)

 Re: ぷるぷるプログラミング

現在、このコミュに参加しやすいように

<自己紹介>
<投稿作品(ソース公開)>
<雑談>

のトピを作成中です(トピの説明の文章を作成中)。

ドット絵エディタの進行状況は、仕事が忙しくて、
保存したドット絵を読み込む作業がまだ出来ないよぉ(o>ω<o)
ところで、ちょっと手直しするところを発見?したので手直し又は関数を追加してみました。
変換用アルファベットをセットする関数を追加しましたよ。
アルファベットが重複するかもしれなのでチェックするようにしました。

WinMainの中で

strcpy( &g_dot.alpha[0], " RGYBMCunstodrgybmcw");

としていたのを、

set_alpha(" RGYBMCunstodrgybmcw");

としました。

コード[C++]: 全て選択
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//-----------------------------------------------------------------------------
// 変換用アルファベットをセットする
//-----------------------------------------------------------------------------
void set_alpha(PSTR alpha)
{
    int  i, j;
    char ch;
   
    for(i=0 ; i<MAX_PALLET; i++){
        ch = alpha[i];
        for(j=0 ; j < MAX_PALLET ; j++){
            if((ch == alpha[j]) && (i != j)){
                msgbox("\"%s\"\n変換用アルファベットの \n%d 文字目と %d 文字目の %c が重複してます。", alpha, i+1, j+1, ch);
                goto label;
            }
        }
    }
label:
    strcpy( &g_dot.alpha[0], alpha);
}


また、関数 set_print を追加して、文字色と背景色をセットするようにしました。
それから print と、msgbox で使うグローバル変数を m_で始まるように変更しました。

コード[C++]: 全て選択
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
//-----------------------------------------------------------------------------
// グローバル変数
//-----------------------------------------------------------------------------
UINT  m_strColor;   // 関数 print の文字の色
UINT  m_bakColor;   // 関数 print の文字の背景色
UINT  m_msgStyle;   // メッセージボックスのスタイル
PSTR  m_msgTitle;   // メッセージボックスのタイトル(デフォルトは "Message")
 
//-----------------------------------------------------------------------------
// メッセージボックスのスタイルとタイトルをセットする
//-----------------------------------------------------------------------------
void set_msgbox(UINT style, PSTR title)
{
    m_msgStyle = style;
    m_msgTitle = title;
}
 
//-----------------------------------------------------------------------------
// 書式付きメッセージボックス
//-----------------------------------------------------------------------------
int msgbox(PSTR pform, ...)
{
    va_list bp;
    char    msg[256];
 
    va_start(bp, pform);
    vsprintf(msg, pform, bp);
    va_end(bp);
 
    return MessageBox(NULL, msg, m_msgTitle, m_msgStyle);
}
 
//-----------------------------------------------------------------------------
// 関数 print の文字色と背景色をセットする
//-----------------------------------------------------------------------------
void set_print(UINT c1, UINT c2)
{
    m_strColor = c1;
    m_bakColor = c2;
}
 
//-----------------------------------------------------------------------------
// 書式付き文字出力
//-----------------------------------------------------------------------------
void print(int x, int y, PSTR pform, ...)
{
    va_list bp;
    char    str[256];
    int     len;
 
    va_start(bp, pform);
    len = vsprintf(str, pform, bp);
    va_end(bp);
 
    DrawBox(x, y, x+len*8, y+16, m_bakColor, TRUE);
    DrawString(x, y, str, m_strColor);
}

Name: どぶろく
[URL]
プログラマー(30,434 ポイント)
Date: 2018年2月07日(水) 21:57
No: 20
(OFFLINE)

 Re: ぷるぷるプログラミング

今日は牡蠣などを運ぶ仕事で5時30分に出勤し、埼玉県まで行ってきたぜ、片道4時間30分、往復9時間じゃん。
ほとんど車の中なので、めっちゃ疲れたわい。ちなみに私の仕事は運送業じゃないよ。
そして、またもや訂正箇所を発見してしまったわい。スペル間違いでした。

コード[C++]: 全て選択
1
#define MAX_PALLET   20

じゃなく

コード[C++]: 全て選択
1
#define MAX_PALETTE   20

でした。しかし、PALETTE より PALLET の方が良くね?フランス語?すべて置き換えてくださいね。
あと、ドット絵を保存する関数が早くも理解不能になりました。
自分で書いたソースなのに読めないのだ(老眼に関係なく)。記憶力の低下・・・
コメントを追加して解かりやすくしました。
ファイルポインタも、ただの p から pFile にしました。

コード[C++]: 全て選択
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
//-----------------------------------------------------------------------------
// ファイルに保存
//-----------------------------------------------------------------------------
EState save(UINT aColor[])
{
    static int  HH=32, WW=32;   // 指定した縦横のドット数を保存
    char szW[128];      // 横ドット数(文字に変換)
    char szH[128];      // 縦ドット数(文字に変換)
    char str[256];      // 書き出す文字列
    FILE *pFile;        // ファイルポインタ
    int  i, j, w, h;
   
    memset(str, 0, 256);
    ClearDrawScreen();
 
    //---------------------------------------
    // 横と縦のドット数を入力する
    //---------------------------------------
    DrawFormatString( 16 , 16 , g_White, "横ドット数 = %d (1~64)" ,  WW) ;
    w = KeyInputNumber( 16*13 , 16 , MESH_W , 1 , TRUE ) ;
    if ( w == MESH_W+1) {   // [ESC]を押された場合
        ClearDrawScreen(); put_dot(aColor);
        return STATE_MAIN;
    }
    else { WW=w; }
 
    DrawFormatString( 16 , 16*3 , g_White, "縦ドット数 = %d (1~32)",  HH) ;
    h = KeyInputNumber( 16*13 , 16*3 , MESH_H , 1 , TRUE ) ;
    if ( h == MESH_H+1) {   // [ESC]を押された場合
        ClearDrawScreen(); put_dot(aColor);
        return STATE_MAIN;
    }
    else { HH=h; }
   
    //---------------------------------------
    // 保存するアルファベットのデータを作成
    //---------------------------------------
    for(j=0; j<h ; j++){
        for(i=0; i<w ; i++){
            g_dot.moji[j][i+1] = g_dot.alpha[g_dot.masu[j][i]];
        }
        g_dot.moji[j][  0]='"';
        g_dot.moji[j][w+1]='"';
        g_dot.moji[j][w+2]=',';
        g_dot.moji[j][w+3]='\n';
        g_dot.moji[j][w+4]='\0';
    }
    g_dot.moji[j-1][w+2]='\0';      // 最後の , を \0 にする。
 
    //---------------------------------------
    // ファイルに書き出す
    //---------------------------------------
    pFile = fopen("ドット絵.txt", "a");
 
    w++;                    // 配列の横の要素数(ドット数)を+1する(文字列の最後にヌル文字が入るので)
    itoa(w, szW, 10);       // 配列の横の要素数(ドット数)を文字に変換
    itoa(h, szH, 10);       // 配列の縦の要素数(ドット数)を文字に変換
   
    strcat(str, "char dot_e[" );
    strcat(str, szH);
    strcat(str, "][");
    strcat(str, szW);
    strcat(str, "]={\n");
 
    fputs("//------------------------------------------------------------------\n", pFile);
    fputs(str, pFile);
    for(i=0; i<h ; i++){
        fputs(&g_dot.moji[i][0], pFile);    // アルファベットのデータをファイルに書き出す
    }
    fputs("\n};\n\n", pFile);
   
    fclose(pFile);
 
    DrawString( 16 , 16*5 , "ドット絵.txt に保存しました。" , g_Yellow ) ;
    ScreenFlip();
    WaitKey();          // キー入力待ち
    ClearDrawScreen();
    put_dot(aColor);
    WaitTimer(200);
   
    return STATE_MAIN;
}

char szW[128]; // 横ドット数(文字に変換)
char szH[128]; // 縦ドット数(文字に変換)
char str[256]; // 書き出す文字列

って要素が多すぎじゃね?(一人つっこみ)


Return to 52歳からはじめるC言語

オンラインデータ

このフォーラムを閲覧中のユーザー: なし & ゲスト[1人]