Форум программистов, компьютерный форум CyberForum.ru

С++ для начинающих

Войти
Регистрация
Восстановить пароль
 
 
Рейтинг: Рейтинг темы: голосов - 37, средняя оценка - 4.76
VS18
0 / 0 / 0
Регистрация: 06.01.2011
Сообщений: 4
#1

создание игры "Точки" - C++

06.01.2011, 15:54. Просмотров 4628. Ответов 58
Метки нет (Все метки)

я только начел программировать. может кто-то уже делал?? Выложите код, чтобы разобраться)
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
06.01.2011, 15:54     создание игры "Точки"
Посмотрите здесь:

C++ Создание структуры "префиксное дерево". Ошибка "Access violation writing location".
C++ Необработанное исключение в "0x00412b4a" в "kursovik.exe": 0xC0000005: Нарушение прав доступа при чтении "0x00000004".
Необработанное исключение в "0x00414558" в "467.exe": 0xC0000005: Нарушение прав доступа при чтении "0xabababbb" C++
C++ Необработанное исключение в "0x01082855" в "sort.exe": 0xC0000005: Нарушение прав доступа при записи "0xcccccccc"
Создание программы наподобие игры "кто хочет стать миллионером" C++
Создание простой игры, каким образом распределить "обязанности" C++
C++ Необработанное исключение в "0x013f2b22" в "123.exe": 0xC0000005: Нарушение прав доступа при записи "0xfdfdfdfd"
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
tomaticus
47 / 47 / 2
Регистрация: 02.01.2011
Сообщений: 505
07.01.2011, 13:55     создание игры "Точки" #41
меня прикалывает то,что вопрос задавал один человек,а общаются другие хД
Vladimir616
111 / 111 / 3
Регистрация: 05.07.2009
Сообщений: 224
07.01.2011, 13:57     создание игры "Точки" #42
isaak, данный код нужно помещать в пустой проект (empty project), чтобы VS не создавала никакие левые заголовочные файлы.
tomaticus
47 / 47 / 2
Регистрация: 02.01.2011
Сообщений: 505
07.01.2011, 14:10     создание игры "Точки" #43
а что,как я понял,мои программы больше никому не нравятся? =)

Добавлено через 11 минут
Vladimir,а ты писал какие нибудь программы? если да,выложи плз
isaak
102 / 39 / 9
Регистрация: 17.10.2010
Сообщений: 653
07.01.2011, 14:18     создание игры "Точки" #44
Vladimir616 я и создавал General -> Empty Project, но откуда VS2008 берет файл bcrypt.h?
Vladimir616
111 / 111 / 3
Регистрация: 05.07.2009
Сообщений: 224
07.01.2011, 14:18     создание игры "Точки" #45
tomaticus, есть ещё FTP клиент, правда я его очень давно писал и качество кода не гарантирую.

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
#define _AFXDLL
#define WINVER 0x0502
#include <afxinet.h>
#include <iostream>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>
#define DOWN 1
#define UP 2
using namespace std;
//--------------------------------------------------------------------------------------------------------------------------------------
CString sUrlAdress;
CString links[1000];
CFtpFileFind *finder;
// Имя сервера
CString sServer;
// Имя объекта на который указывает адрес URL 
CString sObject;
// Номер порта
INTERNET_PORT nPort;
// Тип сервиса или тип протокола
DWORD dwServiceType;
CInternetSession* InternetSession = NULL;
CFtpConnection*  FtpConnection = NULL;
int line = 0;
int number = 0; // кол-во файлов
int deep = 0;
//--------------------------------------------------------------------------------------------------------------------------------------
void Connect();
void CloseSession();
void Move(int);
void ShowContent();
void FTPmain();
void ChangeDirectory();
 
int main()
{
    setlocale(LC_ALL, "rus");
    Connect();
    ShowContent();
    FTPmain();
    CloseSession();
    _getch();
    }
//--------------------------------------------------------------------------------------------------------------------------------------
void Connect()
{
    cout << "Введите адрес сервера, например: ftp://primer.com\n";
    char temp[50]= "", a, login[20] = "", password[20] = "";
    cin >> temp;
    fflush(stdin);
    sUrlAdress = (CString)temp;
    AfxParseURL(sUrlAdress, dwServiceType, sServer, sObject, nPort);
    if(dwServiceType != AFX_INET_SERVICE_FTP)
    {
        cout << "Введённый адрес не является FTP сервером." << endl;
        _getch();
        exit(1);
    }
    cout << "Введите имя пользователя: ";
    for(int i = 0;; i++)
    {
        a = getchar();
        if(a == '\n')
            break;
        login[i] = a;
    }
    cout << "Введите пароль: ";
    for(int i = 0;; i++)
    {
        a = _getch();
        if(a == 13)
            break;
        cout << "*";
        password[i] = a;
    }
    InternetSession = new CInternetSession((LPCTSTR)"Connecter");
    try
    {
        FtpConnection = InternetSession->GetFtpConnection(sServer, (LPCTSTR)login, (LPCTSTR)password);
    }
    catch (CInternetException* pEx)
    {
        cout << "Ошибка соединения с сервером!\n";
        _getch();
        exit(1);
    }
}
 
void CloseSession()
{
    InternetSession -> Close();
    delete InternetSession;
    FtpConnection -> Close();
    delete FtpConnection;
}
 
void Move(int direction)
{
    HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
    COORD position = {0, line};
    SetConsoleCursorPosition(hConsole, position);
    cout << " ";
    if((direction == 1) & !(line >= number - 1))
        line++;
    if((direction == 2) & (line != 0))
        line--;
    position.Y = line;
    SetConsoleCursorPosition(hConsole, position);
    printf("%c", 16);
}
 
void ShowContent()
{
    number = 0;
    system("cls");
    printf("%c", 16);
    line = 0;
    char temp[25] = "";
    bool FirstFile;
    finder = new CFtpFileFind(FtpConnection);
    BOOL h = finder->FindFile((LPCTSTR)"*");
    if(!h)
        cout << "Папка пуста\n";
    else
        FirstFile = true;
    while(h) 
    {
        number++;
        h = finder->FindNextFile();
        links[number] = finder->GetFileName();
        if(links[number]== "." || links[number]== "..")
        {
            number--;
            continue;
        }
        if(!FirstFile)
            cout << " ";
        FirstFile = false;
        cout << links[number] << endl;
    }
    delete finder;
}
 
void FTPmain()
{
    int choose;
    while(true)
    {
        choose = _getch();
        switch(choose)
        {
        case 72: // нажата клавиша вверх
            Move(UP);
            break;
        case 80: // нажата клавиша вниз
            Move(DOWN);
            break;
        case 13:
            deep++;
            ChangeDirectory();
            break;
        case 9:
            {
            HWND h = GetConsoleWindow();
            ShowWindow(h, SW_HIDE);
            FtpConnection->GetFile(links[line+1], links[line+1]);
            CloseSession();
            exit(0);
            break;
            }
        case 27:
            if(deep)
            {
                FtpConnection->SetCurrentDirectory("..");
                deep--;
                ShowContent();
            }
            else
            {
                CloseSession();
                exit(0);
            }
            break;
        }
    }
}
 
void ChangeDirectory()
{
    FtpConnection->SetCurrentDirectory(links[line+1]);
    ShowContent();
}
FTP.rar
Vladimir616
111 / 111 / 3
Регистрация: 05.07.2009
Сообщений: 224
07.01.2011, 14:22     создание игры "Точки" #46
isaak, судя по виду, он вряд ли был создан автоматически, и проблема здесь где-то в настройках студии. Попробуйте просто удалить из него всё содержимое.
isaak
102 / 39 / 9
Регистрация: 17.10.2010
Сообщений: 653
07.01.2011, 14:47     создание игры "Точки" #47
Я удалил файл bcrypt.h запустил на компиляцию VS2008 выдала файл ncrypt.h:
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
//+---------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 2004.
//
//  File:       ncrypt.h
//
//  Contents:   Cryptographic API Prototypes and Definitions
//
//----------------------------------------------------------------------------
 
#ifndef __NCRYPT_H__
#define __NCRYPT_H__
 
#ifdef __cplusplus
extern "C" {
#endif
 
#ifndef WINAPI
#define WINAPI __stdcall
#endif
 
#ifndef __SECSTATUS_DEFINED__
typedef LONG SECURITY_STATUS;
#define __SECSTATUS_DEFINED__
#endif
 
#include <bcrypt.h>
 
 
//
// Microsoft built-in providers.
//
 
#define MS_KEY_STORAGE_PROVIDER         L"Microsoft Software Key Storage Provider"
#define MS_SMART_CARD_KEY_STORAGE_PROVIDER L"Microsoft Smart Card Key Storage Provider"
 
//
// Common algorithm identifiers.
//
 
#define NCRYPT_RSA_ALGORITHM            BCRYPT_RSA_ALGORITHM
#define NCRYPT_RSA_SIGN_ALGORITHM       BCRYPT_RSA_SIGN_ALGORITHM
#define NCRYPT_DH_ALGORITHM             BCRYPT_DH_ALGORITHM
#define NCRYPT_DSA_ALGORITHM            BCRYPT_DSA_ALGORITHM
#define NCRYPT_MD2_ALGORITHM            BCRYPT_MD2_ALGORITHM
#define NCRYPT_MD4_ALGORITHM            BCRYPT_MD4_ALGORITHM
#define NCRYPT_MD5_ALGORITHM            BCRYPT_MD5_ALGORITHM
#define NCRYPT_SHA1_ALGORITHM           BCRYPT_SHA1_ALGORITHM
#define NCRYPT_SHA256_ALGORITHM         BCRYPT_SHA256_ALGORITHM
#define NCRYPT_SHA384_ALGORITHM         BCRYPT_SHA384_ALGORITHM
#define NCRYPT_SHA512_ALGORITHM         BCRYPT_SHA512_ALGORITHM
#define NCRYPT_ECDSA_P256_ALGORITHM     BCRYPT_ECDSA_P256_ALGORITHM
#define NCRYPT_ECDSA_P384_ALGORITHM     BCRYPT_ECDSA_P384_ALGORITHM
#define NCRYPT_ECDSA_P521_ALGORITHM     BCRYPT_ECDSA_P521_ALGORITHM
#define NCRYPT_ECDH_P256_ALGORITHM      BCRYPT_ECDH_P256_ALGORITHM
#define NCRYPT_ECDH_P384_ALGORITHM      BCRYPT_ECDH_P384_ALGORITHM
#define NCRYPT_ECDH_P521_ALGORITHM      BCRYPT_ECDH_P521_ALGORITHM
 
#define NCRYPT_KEY_STORAGE_ALGORITHM            L"KEY_STORAGE"
 
//
// Interfaces
//
 
#define NCRYPT_HASH_INTERFACE                   BCRYPT_HASH_INTERFACE
#define NCRYPT_ASYMMETRIC_ENCRYPTION_INTERFACE  BCRYPT_ASYMMETRIC_ENCRYPTION_INTERFACE
 
#define NCRYPT_SECRET_AGREEMENT_INTERFACE       BCRYPT_SECRET_AGREEMENT_INTERFACE
 
#define NCRYPT_SIGNATURE_INTERFACE              BCRYPT_SIGNATURE_INTERFACE
 
#define NCRYPT_KEY_STORAGE_INTERFACE            0x00010001
#define NCRYPT_SCHANNEL_INTERFACE               0x00010002
 
//
// algorithm groups.
//
 
#define NCRYPT_RSA_ALGORITHM_GROUP      NCRYPT_RSA_ALGORITHM
#define NCRYPT_DH_ALGORITHM_GROUP       NCRYPT_DH_ALGORITHM
#define NCRYPT_DSA_ALGORITHM_GROUP      NCRYPT_DSA_ALGORITHM
#define NCRYPT_ECDSA_ALGORITHM_GROUP    L"ECDSA"
#define NCRYPT_ECDH_ALGORITHM_GROUP     L"ECDH"
 
//
// NCrypt generic memory descriptors
//
 
#define NCRYPTBUFFER_VERSION                0
 
#define NCRYPTBUFFER_EMPTY                  0
#define NCRYPTBUFFER_DATA                   1
#define NCRYPTBUFFER_SSL_CLIENT_RANDOM      20
#define NCRYPTBUFFER_SSL_SERVER_RANDOM      21
#define NCRYPTBUFFER_SSL_HIGHEST_VERSION    22
#define NCRYPTBUFFER_SSL_CLEAR_KEY          23
#define NCRYPTBUFFER_SSL_KEY_ARG_DATA       24
 
#define NCRYPTBUFFER_PKCS_OID               40
#define NCRYPTBUFFER_PKCS_ALG_OID           41
#define NCRYPTBUFFER_PKCS_ALG_PARAM         42
#define NCRYPTBUFFER_PKCS_ALG_ID            43
#define NCRYPTBUFFER_PKCS_ATTRS             44
#define NCRYPTBUFFER_PKCS_KEY_NAME          45
#define NCRYPTBUFFER_PKCS_SECRET            46
 
#define NCRYPTBUFFER_CERT_BLOB              47
 
// NCRYPT shares the same BCRYPT definitions 
typedef BCryptBuffer     NCryptBuffer;
typedef BCryptBuffer*    PNCryptBuffer;
typedef BCryptBufferDesc NCryptBufferDesc;
typedef BCryptBufferDesc* PNCryptBufferDesc;
 
//
// NCrypt handles
//
 
typedef ULONG_PTR NCRYPT_HANDLE;
typedef ULONG_PTR NCRYPT_PROV_HANDLE;
typedef ULONG_PTR NCRYPT_KEY_HANDLE;
typedef ULONG_PTR NCRYPT_HASH_HANDLE;
typedef ULONG_PTR NCRYPT_SECRET_HANDLE;
 
 
//
// NCrypt API Flags
//
 
#define NCRYPT_NO_PADDING_FLAG      BCRYPT_PAD_NONE
#define NCRYPT_PAD_PKCS1_FLAG       BCRYPT_PAD_PKCS1  // NCryptEncrypt/Decrypt NCryptSignHash/VerifySignature
#define NCRYPT_PAD_OAEP_FLAG        BCRYPT_PAD_OAEP   // BCryptEncrypt/Decrypt
#define NCRYPT_PAD_PSS_FLAG         BCRYPT_PAD_PSS    // BCryptSignHash/VerifySignature
#define NCRYPT_NO_KEY_VALIDATION    BCRYPT_NO_KEY_VALIDATION
#define NCRYPT_MACHINE_KEY_FLAG                 0x00000020  // same as CAPI CRYPT_MACHINE_KEYSET
#define NCRYPT_SILENT_FLAG                      0x00000040  // same as CAPI CRYPT_SILENT
#define NCRYPT_OVERWRITE_KEY_FLAG               0x00000080
#define NCRYPT_WRITE_KEY_TO_LEGACY_STORE_FLAG   0x00000200
#define NCRYPT_DO_NOT_FINALIZE_FLAG             0x00000400
#define NCRYPT_PERSIST_ONLY_FLAG                0x40000000
#define NCRYPT_PERSIST_FLAG                     0x80000000
#define NCRYPT_REGISTER_NOTIFY_FLAG             0x00000001
#define NCRYPT_UNREGISTER_NOTIFY_FLAG           0x00000002
 
 
//
// Functions used to manage persisted keys.
//
 
SECURITY_STATUS
WINAPI
NCryptOpenStorageProvider(
    __out   NCRYPT_PROV_HANDLE *phProvider,
    __in_opt LPCWSTR pszProviderName,
    __in    DWORD   dwFlags);
 
 
 
// AlgOperations flags for use with NCryptEnumAlgorithms()
#define NCRYPT_CIPHER_OPERATION                 BCRYPT_CIPHER_OPERATION
#define NCRYPT_HASH_OPERATION                   BCRYPT_HASH_OPERATION
#define NCRYPT_ASYMMETRIC_ENCRYPTION_OPERATION  BCRYPT_ASYMMETRIC_ENCRYPTION_OPERATION
#define NCRYPT_SECRET_AGREEMENT_OPERATION       BCRYPT_SECRET_AGREEMENT_OPERATION
#define NCRYPT_SIGNATURE_OPERATION              BCRYPT_SIGNATURE_OPERATION
#define NCRYPT_RNG_OPERATION                    BCRYPT_RNG_OPERATION
 
// USE EXTREME CAUTION: editing comments that contain "certenrolls_*" tokens
// could break building CertEnroll idl files:
// certenrolls_begin -- NCryptAlgorithmName
typedef struct _NCryptAlgorithmName
{
    LPWSTR  pszName;
    DWORD   dwClass;            // the CNG interface that supports this algorithm
    DWORD   dwAlgOperations;    // the types of operations supported by this algorithm
    DWORD   dwFlags;
} NCryptAlgorithmName;
// certenrolls_end
 
SECURITY_STATUS
WINAPI
NCryptEnumAlgorithms(
    __in    NCRYPT_PROV_HANDLE hProvider,
    __in    DWORD   dwAlgOperations,
    __out   DWORD * pdwAlgCount,
    __deref_out_ecount(*pdwAlgCount) NCryptAlgorithmName **ppAlgList,
    __in    DWORD   dwFlags);
 
 
 
SECURITY_STATUS
WINAPI
NCryptIsAlgSupported(
    __in    NCRYPT_PROV_HANDLE hProvider,
    __in    LPCWSTR pszAlgId,
    __in    DWORD   dwFlags);
 
 
 
// NCryptEnumKeys flags
#define NCRYPT_MACHINE_KEY_FLAG         0x00000020
 
typedef struct NCryptKeyName
{
    LPWSTR  pszName;
    LPWSTR  pszAlgid;
    DWORD   dwLegacyKeySpec;
    DWORD   dwFlags;
} NCryptKeyName;
 
SECURITY_STATUS
WINAPI
NCryptEnumKeys(
    __in    NCRYPT_PROV_HANDLE hProvider,
    __in_opt LPCWSTR pszScope,
    __deref_out NCryptKeyName **ppKeyName,
    __inout PVOID * ppEnumState,
    __in    DWORD   dwFlags);
 
 
 
typedef struct NCryptProviderName
{
    LPWSTR  pszName;
    LPWSTR  pszComment;
} NCryptProviderName;
 
SECURITY_STATUS
WINAPI
NCryptEnumStorageProviders(
    __out   DWORD * pdwProviderCount,
    __deref_out_ecount(*pdwProviderCount) NCryptProviderName **ppProviderList,
    __in    DWORD   dwFlags);
 
 
 
SECURITY_STATUS
WINAPI
NCryptFreeBuffer(
    __deref PVOID   pvInput);
 
 
 
// NCryptOpenKey flags
#define NCRYPT_MACHINE_KEY_FLAG         0x00000020
#define NCRYPT_SILENT_FLAG              0x00000040
 
SECURITY_STATUS
WINAPI
NCryptOpenKey(
    __inout NCRYPT_PROV_HANDLE hProvider,
    __out   NCRYPT_KEY_HANDLE *phKey,
    __in    LPCWSTR pszKeyName,
    __in_opt DWORD  dwLegacyKeySpec,
    __in    DWORD   dwFlags);
 
 
 
// NCryptCreatePersistedKey flags
#define NCRYPT_MACHINE_KEY_FLAG         0x00000020
#define NCRYPT_OVERWRITE_KEY_FLAG       0x00000080
 
SECURITY_STATUS
WINAPI
NCryptCreatePersistedKey(
    __in    NCRYPT_PROV_HANDLE hProvider,
    __out   NCRYPT_KEY_HANDLE *phKey,
    __in    LPCWSTR pszAlgId,
    __in_opt LPCWSTR pszKeyName,
    __in    DWORD   dwLegacyKeySpec,
    __in    DWORD   dwFlags);
 
 
 
// Standard property names.
#define NCRYPT_NAME_PROPERTY                    L"Name"
#define NCRYPT_UNIQUE_NAME_PROPERTY             L"Unique Name"
#define NCRYPT_ALGORITHM_PROPERTY               L"Algorithm Name"
#define NCRYPT_LENGTH_PROPERTY                  L"Length"
#define NCRYPT_LENGTHS_PROPERTY                 L"Lengths"
#define NCRYPT_BLOCK_LENGTH_PROPERTY            L"Block Length"
#define NCRYPT_UI_POLICY_PROPERTY               L"UI Policy"
#define NCRYPT_EXPORT_POLICY_PROPERTY           L"Export Policy"
#define NCRYPT_WINDOW_HANDLE_PROPERTY           L"HWND Handle"
#define NCRYPT_USE_CONTEXT_PROPERTY             L"Use Context"
#define NCRYPT_IMPL_TYPE_PROPERTY               L"Impl Type"
#define NCRYPT_KEY_USAGE_PROPERTY               L"Key Usage"
#define NCRYPT_KEY_TYPE_PROPERTY                L"Key Type"
#define NCRYPT_VERSION_PROPERTY                 L"Version"
#define NCRYPT_SECURITY_DESCR_SUPPORT_PROPERTY  L"Security Descr Support"
#define NCRYPT_SECURITY_DESCR_PROPERTY          L"Security Descr"
#define NCRYPT_USE_COUNT_ENABLED_PROPERTY       L"Enabled Use Count"
#define NCRYPT_USE_COUNT_PROPERTY               L"Use Count"
#define NCRYPT_LAST_MODIFIED_PROPERTY           L"Modified"
#define NCRYPT_MAX_NAME_LENGTH_PROPERTY         L"Max Name Length"
#define NCRYPT_ALGORITHM_GROUP_PROPERTY         L"Algorithm Group"
#define NCRYPT_DH_PARAMETERS_PROPERTY           BCRYPT_DH_PARAMETERS
#define NCRYPT_PROVIDER_HANDLE_PROPERTY         L"Provider Handle"
#define NCRYPT_PIN_PROPERTY                     L"SmartCardPin"
#define NCRYPT_READER_PROPERTY                  L"SmartCardReader"
#define NCRYPT_SMARTCARD_GUID_PROPERTY          L"SmartCardGuid"
#define NCRYPT_CERTIFICATE_PROPERTY             L"SmartCardKeyCertificate"
#define NCRYPT_PIN_PROMPT_PROPERTY              L"SmartCardPinPrompt"
#define NCRYPT_USER_CERTSTORE_PROPERTY          L"SmartCardUserCertStore"
#define NCRYPT_ROOT_CERTSTORE_PROPERTY          L"SmartcardRootCertStore"
 
// Maximum length of property name (in characters)
#define NCRYPT_MAX_PROPERTY_NAME        64
 
// Maximum length of property data (in bytes)
#define NCRYPT_MAX_PROPERTY_DATA        0x100000
 
// NCRYPT_EXPORT_POLICY_PROPERTY property flags.
#define NCRYPT_ALLOW_EXPORT_FLAG                0x00000001
#define NCRYPT_ALLOW_PLAINTEXT_EXPORT_FLAG      0x00000002
#define NCRYPT_ALLOW_ARCHIVING_FLAG             0x00000004
#define NCRYPT_ALLOW_PLAINTEXT_ARCHIVING_FLAG   0x00000008
 
// NCRYPT_IMPL_TYPE_PROPERTY property flags.
#define NCRYPT_IMPL_HARDWARE_FLAG               0x00000001
#define NCRYPT_IMPL_SOFTWARE_FLAG               0x00000002
#define NCRYPT_IMPL_REMOVABLE_FLAG              0x00000008
#define NCRYPT_IMPL_HARDWARE_RNG_FLAG           0x00000010
 
// NCRYPT_KEY_USAGE_PROPERTY property flags.
#define NCRYPT_ALLOW_DECRYPT_FLAG               0x00000001
#define NCRYPT_ALLOW_SIGNING_FLAG               0x00000002
#define NCRYPT_ALLOW_KEY_AGREEMENT_FLAG         0x00000004
#define NCRYPT_ALLOW_ALL_USAGES                 0x00ffffff
 
// NCRYPT_UI_POLICY_PROPERTY property flags and structure
#define NCRYPT_UI_PROTECT_KEY_FLAG              0x00000001
#define NCRYPT_UI_FORCE_HIGH_PROTECTION_FLAG    0x00000002
 
typedef struct __NCRYPT_UI_POLICY_BLOB
{
    DWORD   dwVersion;
    DWORD   dwFlags;
    DWORD   cbCreationTitle;
    DWORD   cbFriendlyName;
    DWORD   cbDescription;
    // creation title string
    // friendly name string
    // description string
} NCRYPT_UI_POLICY_BLOB;
 
typedef struct __NCRYPT_UI_POLICY
{
    DWORD   dwVersion;
    DWORD   dwFlags;
    LPCWSTR pszCreationTitle;
    LPCWSTR pszFriendlyName;
    LPCWSTR pszDescription;
} NCRYPT_UI_POLICY;
 
 
// NCRYPT_LENGTHS_PROPERTY property structure.
typedef struct __NCRYPT_SUPPORTED_LENGTHS
{
    DWORD   dwMinLength;
    DWORD   dwMaxLength;
    DWORD   dwIncrement;
    DWORD   dwDefaultLength;
} NCRYPT_SUPPORTED_LENGTHS;
 
// NCryptGetProperty flags
#define NCRYPT_PERSIST_ONLY_FLAG        0x40000000
 
SECURITY_STATUS
WINAPI
NCryptGetProperty(
    __in    NCRYPT_HANDLE hObject,
    __in    LPCWSTR pszProperty,
    __out_bcount_part_opt(cbOutput, *pcbResult) PBYTE pbOutput,
    __in    DWORD   cbOutput,
    __out   DWORD * pcbResult,
    __in    DWORD   dwFlags);
 
 
 
// NCryptSetProperty flags
#define NCRYPT_PERSIST_FLAG             0x80000000
#define NCRYPT_PERSIST_ONLY_FLAG        0x40000000
 
SECURITY_STATUS
WINAPI
NCryptSetProperty(
    __in    NCRYPT_HANDLE hObject,
    __in    LPCWSTR pszProperty,
    __in_bcount(cbInput) PBYTE pbInput,
    __in    DWORD   cbInput,
    __in    DWORD   dwFlags);
 
 
 
#define     NCRYPT_WRITE_KEY_TO_LEGACY_STORE_FLAG   0x00000200
 
SECURITY_STATUS
WINAPI
NCryptFinalizeKey(
    __in    NCRYPT_KEY_HANDLE hKey,
    __in    DWORD   dwFlags);
 
 
 
SECURITY_STATUS
WINAPI
NCryptEncrypt(
    __in    NCRYPT_KEY_HANDLE hKey,
    __in_bcount(cbInput) PBYTE pbInput,
    __in    DWORD   cbInput,
    __in_opt    VOID *pPaddingInfo,
    __out_bcount_part_opt(cbOutput, *pcbResult) PBYTE pbOutput,
    __in    DWORD   cbOutput,
    __out   DWORD * pcbResult,
    __in    DWORD   dwFlags);
 
 
 
SECURITY_STATUS
WINAPI
NCryptDecrypt(
    __in    NCRYPT_KEY_HANDLE hKey,
    __in_bcount(cbInput) PBYTE pbInput,
    __in    DWORD   cbInput,
    __in_opt    VOID *pPaddingInfo,
    __out_bcount_part_opt(cbOutput, *pcbResult) PBYTE pbOutput,
    __in    DWORD   cbOutput,
    __out   DWORD * pcbResult,
    __in    DWORD   dwFlags);
 
 
 
#define NCRYPT_PKCS7_ENVELOPE_BLOB      L"PKCS7_ENVELOPE"
#define NCRYPT_PKCS8_PRIVATE_KEY_BLOB   L"PKCS8_PRIVATEKEY"
#define NCRYPT_OPAQUETRANSPORT_BLOB     L"OpaqueTransport"
 
#define NCRYPT_MACHINE_KEY_FLAG         0x00000020
#define NCRYPT_DO_NOT_FINALIZE_FLAG     0x00000400
 
SECURITY_STATUS
WINAPI
NCryptImportKey(
    __in    NCRYPT_PROV_HANDLE hProvider,
    __in_opt NCRYPT_KEY_HANDLE hImportKey,
    __in    LPCWSTR pszBlobType,
    __in_opt NCryptBufferDesc *pParameterList,
    __out   NCRYPT_KEY_HANDLE *phKey,
    __in_bcount(cbData) PBYTE pbData,
    __in    DWORD   cbData,
    __in    DWORD   dwFlags);
 
 
 
SECURITY_STATUS
WINAPI
NCryptExportKey(
    __in    NCRYPT_KEY_HANDLE hKey,
    __in_opt NCRYPT_KEY_HANDLE hExportKey,
    __in    LPCWSTR pszBlobType,
    __in_opt NCryptBufferDesc *pParameterList,
    __out_bcount_part_opt(cbOutput, *pcbResult) PBYTE pbOutput,
    __in    DWORD   cbOutput,
    __out   DWORD * pcbResult,
    __in    DWORD   dwFlags);
 
 
 
SECURITY_STATUS
WINAPI
NCryptSignHash(
    __in    NCRYPT_KEY_HANDLE hKey,
    __in_opt    VOID *pPaddingInfo,
    __in_bcount(cbHashValue) PBYTE pbHashValue,
    __in    DWORD   cbHashValue,
    __out_bcount_part_opt(cbSignature, *pcbResult) PBYTE pbSignature,
    __in    DWORD   cbSignature,
    __out   DWORD * pcbResult,
    __in    DWORD   dwFlags);
 
 
 
SECURITY_STATUS
WINAPI
NCryptVerifySignature(
    __in    NCRYPT_KEY_HANDLE hKey,
    __in_opt    VOID *pPaddingInfo,
    __in_bcount(cbHashValue) PBYTE pbHashValue,
    __in    DWORD   cbHashValue,
    __in_bcount(cbSignature) PBYTE pbSignature,
    __in    DWORD   cbSignature,
    __in    DWORD   dwFlags);
 
 
 
SECURITY_STATUS
WINAPI
NCryptDeleteKey(
    __in    NCRYPT_KEY_HANDLE hKey,
    __in    DWORD   dwFlags);
 
 
 
SECURITY_STATUS
WINAPI
NCryptFreeObject(
    __in    NCRYPT_HANDLE hObject);
 
 
 
BOOL
WINAPI
NCryptIsKeyHandle(
    __in    NCRYPT_KEY_HANDLE hKey);
 
SECURITY_STATUS
WINAPI
NCryptTranslateHandle(
    __out_opt NCRYPT_PROV_HANDLE *phProvider,
    __out   NCRYPT_KEY_HANDLE *phKey,
    __in    HCRYPTPROV hLegacyProv,
    __in_opt HCRYPTKEY hLegacyKey,
    __in_opt DWORD  dwLegacyKeySpec,
    __in    DWORD   dwFlags);
 
 
 
// NCryptNotifyChangeKey flags
#define NCRYPT_REGISTER_NOTIFY_FLAG     0x00000001
#define NCRYPT_UNREGISTER_NOTIFY_FLAG   0x00000002
#define NCRYPT_MACHINE_KEY_FLAG         0x00000020
 
SECURITY_STATUS
WINAPI
NCryptNotifyChangeKey(
    __in    NCRYPT_PROV_HANDLE hProvider,
    __inout HANDLE *phEvent,
    __in    DWORD   dwFlags);
 
 
 
SECURITY_STATUS
WINAPI
NCryptSecretAgreement(
    __in    NCRYPT_KEY_HANDLE hPrivKey,
    __in    NCRYPT_KEY_HANDLE hPubKey,
    __out   NCRYPT_SECRET_HANDLE *phAgreedSecret,
    __in    DWORD   dwFlags);
 
 
 
SECURITY_STATUS
WINAPI
NCryptDeriveKey(
    __in        NCRYPT_SECRET_HANDLE hSharedSecret,
    __in        LPCWSTR              pwszKDF,
    __in_opt    NCryptBufferDesc     *pParameterList,
    __out_bcount_part_opt(cbDerivedKey, *pcbResult) PBYTE pbDerivedKey,
    __in        DWORD                cbDerivedKey,
    __out       DWORD                *pcbResult,
    __in        ULONG                dwFlags);
 
 
 
#define NCRYPT_KEY_STORAGE_INTERFACE_VERSION BCRYPT_MAKE_INTERFACE_VERSION(1,0)
 
 
 
#ifdef __cplusplus
}       // Balance extern "C" above
#endif
 
#endif // __NCRYPT_H__
На сколько я понял тут че то связано с шифрованием. Подскажите пожалуйста где и как в настройках VS2008 отлкючить это долбаное шифрование, очень хочется посмотреть как работает программа заранее огромное спасибо.
Vladimir616
111 / 111 / 3
Регистрация: 05.07.2009
Сообщений: 224
07.01.2011, 15:00     создание игры "Точки" #48
isaak, с отключением шифрования я вам не помогу, но если вы хотите увидеть работу программы - к посту с исходным кодом прикреплён архив с исполняемым файлом, если у вас установлена VS то он должен запуститься.
isaak
102 / 39 / 9
Регистрация: 17.10.2010
Сообщений: 653
07.01.2011, 16:26     создание игры "Точки" #49
Vladimir616 у меня ваш проект не запускается у вас в архиве только один exeшник и когда его запускаешь возникает ошибка требуются дополнительные файлы, скорей всего ваш проект содержит динамические библиотеки, может скинуть его полностью с библиотеками или создать его статическим (вместо Debug -> Realse). Заранее огромное спасибо.
Vladimir616
111 / 111 / 3
Регистрация: 05.07.2009
Сообщений: 224
07.01.2011, 16:47     создание игры "Точки" #50
isaak, это и был release проект. Возможно, у вас запустится тот, что в прикреплённом файле, я его пересобрал на 2010 студии с дополнительными параметрами, есть небольшая надежда, что это сделает его компьютеронезависимым, правда теперь для его запуска может потребоваться .Net 4 .
Snake.rar
isaak
102 / 39 / 9
Регистрация: 17.10.2010
Сообщений: 653
07.01.2011, 20:50     создание игры "Точки" #51
Vladimir616 все таки я заставил себя установить VS2010 и у меня запустился ваш exe и с компилировался ваш программированный код. У меня возникает вопрос может у меня в VS2008 возникали ошибки с хренью типа создания заголовочных файлов шифрования из-за того что VS2008 нет лямда-выражений и LINQ -языка встроенных запросов, хотя вроде вы про них вы ни чего не говорили. Прошу не судить меня строго это только мои догадки.
Vladimir616
111 / 111 / 3
Регистрация: 05.07.2009
Сообщений: 224
07.01.2011, 21:25     создание игры "Точки" #52
isaak, подобных проблем возникать не должно, т.к программа изначально была написана в VS2008.
isaak
102 / 39 / 9
Регистрация: 17.10.2010
Сообщений: 653
07.01.2011, 22:39     создание игры "Точки" #53
Скорей всего здесь дело в образе VS2008, возможно в образе с которого я устанавливал VS2008 эти лямбда-выражения убрали, либо после установки VS2008 нужно провести какие-то настройки чтобы включить поддержку лямбда-выражений, опять это только предположения.

Добавлено через 31 минуту
Огромное спасибо
VS18
0 / 0 / 0
Регистрация: 06.01.2011
Сообщений: 4
08.01.2011, 14:55  [ТС]     создание игры "Точки" #54
спасибо за змейку)
shalisan
3 / 3 / 1
Регистрация: 29.08.2012
Сообщений: 40
19.10.2012, 02:50     создание игры "Точки" #55
Цитата Сообщение от Vladimir616 Посмотреть сообщение
Вот змейка:

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
// Тихонов Владимир, [email]Tikhonow.Vladimir@gmail.com[/email]
#include <iostream>
#include <windows.h>
#include <conio.h>
#include <time.h>
#define BLUE 9
#define GREEN 10
#define WHITE 11
#define RED 12
#define YELLOW 14
#define VERTICAL_SPEED 140 // чем больше показатель, тем меньше скорость
#define HORISONTAL_SPEED 70
using namespace std;
//--------------------------------------------------------------------------------------------------------------------------
COORD AppleCord = {0,0}; // координаты яблока
COORD coord[100] = {0}; // коордиаты змеи
int direction = 4; //направление движения : 1 - вверх, 2 - вниз, 3 - влево, 4 - вправо.
int SnakeLength = 6; // длинна змеи
void SetAndDraw(int x, int y, char symbol[100] = "_", int color = WHITE); // умеет двигать курсор, выводить любой текст
//разными цветами
void DrawInfo(); // рисует поле и прочую фигню
void DrawApple(); // рисует яблоко
void SnakeMain(); // управление змейкой
void MoveSnake(); // передвижение змейки
void CheckForEvents(); // а не случилось что со змейкой?
void ShowLoseScreen();
//--------------------------------------------------------------------------------------------------------------------------
int main()
{
    setlocale(LC_ALL, "rus");
    DrawInfo();
    DrawApple();
    SnakeMain();
    return 0;
}
//--------------------------------------------------------------------------------------------------------------------------
void SetAndDraw(int x, int y, char symbol[100], int color)
{
    int temp = 0;
    HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
    COORD position = {x, y};
    SetConsoleCursorPosition(hConsole, position);
    if(color != WHITE)
    {
        SetConsoleTextAttribute(hConsole, color);
        temp = 1;
    }
    if(symbol != "_")
        cout << symbol;
    if(temp)
        SetConsoleTextAttribute(hConsole, WHITE);
}
void DrawInfo()
{
    SetAndDraw(32, 0, "Змейка v1.1", YELLOW);
    SetAndDraw(25, 1, "Тихонов Владимир, (c) 2009", YELLOW);
    // рисуем границы
    for(int i = 0; i<80; i++) // верх
        SetAndDraw(i, 3, "#", RED);
    for(int i = 4; i<22; i++) // левая сторона
        SetAndDraw(0, i, "#", RED);
    for(int i = 1; i<80; i++) // низ
        SetAndDraw(i, 21, "#", RED);
    for(int i = 21; i>3; i--) // правая сторона
        SetAndDraw(79, i, "#", RED);
    SetAndDraw(0, 23,"   Управление: ", BLUE);
    cout.put(24);
    SetAndDraw(17, 23, " - вверх, ", BLUE);
    cout.put(25);
    SetAndDraw(28, 23, " - вниз, ", BLUE);
    cout.put(27);
    SetAndDraw(38, 23, " - влево, ", BLUE);
    cout.put(26);
    SetAndDraw(49, 23, " - вправо, ", BLUE);
    SetAndDraw(60, 23, "пробел");
    SetAndDraw(66, 23, " - пауза.", BLUE);
}
void DrawApple()
{
    HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
    SetConsoleTextAttribute(hConsole, YELLOW);
    srand(time(0));
    AppleCord.X = rand() % 78 + 1;
    AppleCord.Y = rand() % 16 + 4;
    SetAndDraw(AppleCord.X, AppleCord.Y);
    cout.put(4);
    SetConsoleTextAttribute(hConsole, WHITE);
}
void SnakeMain()
{
    int choose, speed;
    SetAndDraw(5, 18, "ooooo", GREEN);
    cout.put(1);
    for(int i = 0, k = 10; i <= SnakeLength; i++, k--) // задаём начальные координаты
    {
        coord[i].X = k;
        coord[i].Y = 18;
    }
    while(true)
    {
        if(direction == 1 || direction == 2)
            speed = VERTICAL_SPEED;
        else
            speed = HORISONTAL_SPEED;
        while(!_kbhit()) // пока  ничего не нажато
        {
            MoveSnake();
            Sleep(speed);
        }
        choose = _getch();
        switch(choose)
        {
            case 72: // нажата клавиша вверх
                if(direction != 2)
                    direction = 1;
                break;
            case 80: // нажата клавиша вниз
                if(direction != 1)
                    direction = 2;
                break;
            case 75: // нажата клавиша влево
                if(direction != 4)
                    direction = 3;
                break;
            case 77: // нажата клавиша вправо
                if(direction != 3)
                    direction = 4;
                break;
            case 32: // нажат пробел
                _getch();
        }
    }
}
void MoveSnake()
{
    COORD temp, temp1;
    for(int i = 0; i <= SnakeLength; i++) // новые координаты
    {
        if(i == 0) // для головы в зависимости от направления
        {
            temp = coord[i];
            if(direction == 1)
                coord[i].Y--;
            if(direction == 2)
                coord[i].Y++;
            if(direction == 3)
                coord[i].X--;
            if(direction == 4)
                coord[i].X++;
        }
        else // для туловища просто присваиваем старую координату впередиидущего кружка
        {
            temp1 = temp;
            temp = coord[i];
            coord[i] = temp1;
        }
    }
        SetAndDraw(coord[SnakeLength].X, coord[SnakeLength].Y, " "); // стираем хвост
        SetAndDraw(coord[0].X, coord[0].Y); // рисуем голову
        cout.put(1);
        SetAndDraw(coord[1].X, coord[1].Y, "o", GREEN); // вместо старой головы рисуем кружок
        CheckForEvents();
}
void CheckForEvents()
{
    if(coord[0].X == 0 || coord[0].X == 79 || coord[0].Y == 3 || coord[0].Y == 21) // встретились со стеной
    {
        ShowLoseScreen();
    }
    if((coord[0].X == AppleCord.X) & (coord[0].Y == AppleCord.Y)) // сьели яблоко
    {
        SnakeLength++;
        DrawApple();
    }
    for(int i = 1; i <= SnakeLength; i++) // наткнулись на себя
        if((coord[0].X == coord[i].X) & (coord[0].Y == coord[i].Y))
        {
            ShowLoseScreen();
        }
}
void ShowLoseScreen()
{
    system("cls");
    int i = 3;
    while(i)
    {
        SetAndDraw(33, 11, "Вы проиграли", RED);
        Sleep(600);
        SetAndDraw(33, 11, "            ");
        Sleep(500);
        i--;
    }
    exit(0);
}
Вложение 57312
такой вопрос какой язык программирования нужно познать чтобы сделать подобный шедевр?)
isaak
102 / 39 / 9
Регистрация: 17.10.2010
Сообщений: 653
19.10.2012, 21:31     создание игры "Точки" #56
Приведенная выше игра написана на C++ консольное приложение. Можете написать на С# или Visual Basic, Delphi, Java и так далее. Какой язык хорошо знаете на том и пишите.
Mr.X
Эксперт С++
3039 / 1684 / 265
Регистрация: 03.05.2010
Сообщений: 3,867
23.10.2012, 21:30     создание игры "Точки" #57
Цитата Сообщение от shalisan Посмотреть сообщение
такой вопрос какой язык программирования нужно познать чтобы сделать подобный шедевр?)
Ну, это на Си написано. На 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
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
/////////////////////////////////////////////////////////////////////////////////////////
#include <windows.h>
#include <conio.h>
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <iostream>
#include <map>
#include <set>
#include <sstream>
#include <string>
#include <utility>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string     T_str;
/////////////////////////////////////////////////////////////////////////////////////////
class  T_snake
{
    //-----------------------------------------------------------------------------------
    struct  T_col_row
    {
        int     col_;
        int     row_;
        //-------------------------------------------------------------------------------
        T_col_row
            (
                int     col     =   0,
                int     row     =   0
            )
            :
            col_    ( col ),
            row_    ( row )
        {}
        //-------------------------------------------------------------------------------
        bool  operator<(const T_col_row&  pos)  const
        {
            return      std::make_pair
                            (
                                col_,
                                row_
                            )
 
                    <   std::make_pair
                            (
                                pos.col_,
                                pos.row_
                            );
        }
        //-------------------------------------------------------------------------------
        bool  operator!=( T_col_row  pos )      const
        {
            return      *this   <   pos
                    ||  pos     <   *this;
        }
        //-------------------------------------------------------------------------------
        bool  operator==( T_col_row  pos )      const
        {
            return  !( *this    !=  pos );
        }
        //-------------------------------------------------------------------------------
        operator COORD()                        const
        {
            COORD   res =   {
                                col_,
                                row_
                            };
 
            return  res;
        }
        //-------------------------------------------------------------------------------
        void  shift_to_left     ()
        {
            --col_;
        }
        //-------------------------------------------------------------------------------
        void  shift_to_right    ()
        {
            ++col_;
        }
        //-------------------------------------------------------------------------------
        void  shift_up          ()
        {
            --row_;
        }
        //-------------------------------------------------------------------------------
        void  shift_down        ()
        {
            ++row_;
        }
        //-------------------------------------------------------------------------------
    };
    //-----------------------------------------------------------------------------------
    typedef std::deque  <T_col_row>   T_positions_deque;
    typedef std::set    <T_col_row>   T_positions_set;
    //-----------------------------------------------------------------------------------
    enum  T_direction
    {
        LEFT_DIRECTION,
        RIGHT_DIRECTION,
        UP_DIRECTION,
        DOWN_DIRECTION
    };
    //-----------------------------------------------------------------------------------
    enum  T_conrol_key
    {
        LEFT_DIR_KEY    =   75,
        RIGHT_DIR_KEY   =   77,
        UP_DIR_KEY      =   72,
        DOWN_DIR_KEY    =   80,
        PAUSE_KEY       =   ' '
    };
    //-----------------------------------------------------------------------------------
    enum  T_color
    {
        BLUE    =   9,
        GREEN   =   10,
        WHITE   =   11,
        RED     =   12,
        YELLOW  =   14
    };
    //-----------------------------------------------------------------------------------
    typedef std::map<T_conrol_key, T_direction>  T_direction_of_key;
    //-----------------------------------------------------------------------------------
    static const char       FIELD_SYMB                  =   ' ';
    static const char       BORDER_SYMB                 =   '#';
    static const char       SNAKE_HEAD_SYMB             =   1;
    static const char       SNAKE_BODY_SYMB             =   111;
    static const char       APPLE_SYMB                  =   4;
 
    static const char       UPWARDS_ARROW               =   24;
    static const char       DOWNWARDS_ARROW             =   25;
    static const char       RIGHTWARDS_ARROW            =   26;
    static const char       LEFTWARDS_ARROW             =   27;
 
    static const T_color    BORDER_COLOR                =   RED;
    static const T_color    APPLE_COLOR                 =   YELLOW;
    static const T_color    SNAKE_COLOR                 =   GREEN;
 
    static const int        FIELD_WIDTH                 =   80;
    static const int        FIELD_HIGHT                 =   20;
 
    static const int        LEFT_FIELD_COL              =   0;
    static const int        CENTER_FIELD_COL            =   LEFT_FIELD_COL  +   FIELD_WIDTH     /   2;
    static const int        RIGHT_FIELD_COL             =   LEFT_FIELD_COL  +   FIELD_WIDTH     -   1;
 
    static const int        HEADLINE_ROW                =   0;
 
    static const int        TOP_FIELD_ROW               =   1;
    static const int        CENTER_FIELD_ROW            =   TOP_FIELD_ROW   +   FIELD_HIGHT     /   2;
    static const int        BOTTOM_FIELD_ROW            =   TOP_FIELD_ROW   +   FIELD_HIGHT     -   1;
 
    static const int        START_MILLISEC_PER_STEP     =   100;
 
    static const size_t     START_SNAKE_LEN             =   6;
    //-----------------------------------------------------------------------------------
    bool                pause_indicator_;
    HANDLE              hConsole_;
    int                 millisec_per_step_;
 
    T_direction_of_key  direction_of_key_;
    T_positions_deque   snake_body_positions_deque_;
 
    T_col_row           apple_pos_;
    T_conrol_key        cur_conrol_key_;
    T_direction         cur_direction_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_snake()
        :
        pause_indicator_    ( false ),
        hConsole_
            (
                GetStdHandle( STD_OUTPUT_HANDLE )
            ),        
        millisec_per_step_  ( START_MILLISEC_PER_STEP )
        
    {
        direction_of_key_[ LEFT_DIR_KEY     ]   =   LEFT_DIRECTION;
        direction_of_key_[ RIGHT_DIR_KEY    ]   =   RIGHT_DIRECTION;
        direction_of_key_[ UP_DIR_KEY       ]   =   UP_DIRECTION;
        direction_of_key_[ DOWN_DIR_KEY     ]   =   DOWN_DIRECTION;
 
        make_start_snake_body   ();
        draw_snake_body         ();
        draw_apple_in_rand_pos  ();
    }
    //-----------------------------------------------------------------------------------
    void  make_start_snake_body()
    {
        cur_direction_  =   rand() % 2
                                ? RIGHT_DIRECTION
                                : LEFT_DIRECTION;
 
        T_col_row   cur_snake_body_pos
                        (
                            CENTER_FIELD_COL,
                            CENTER_FIELD_ROW
                        );
 
        for( int  i = 0; i < START_SNAKE_LEN; ++i )
        {
            snake_body_positions_deque_.push_front( cur_snake_body_pos );
 
            shift_position_in_direction
                (
                    cur_snake_body_pos,
                    cur_direction_
                );
        }
    }
    //-----------------------------------------------------------------------------------
    void  play()
    {
        print_field_border                                                          ();
        print_info                                                                  ();
        operated_eating_of_apples_before_collision_with_border_or_with_own_body     ();
        clear_screen                                                                ();
        print_result                                                                ();
        make_pause_to_pressing_of_any_key                                           ();
    }
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    static void  clear_screen()
    {
        system("cls");
    }
    //-----------------------------------------------------------------------------------
    void  print_result()    const
    {
        int     result  =   snake_body_positions_deque_.size() - START_SNAKE_LEN;
 
        std::ostringstream  sout;
        sout    <<  "Съедено яблок "
                <<  result
                <<  ".";
 
        print_text_with_color_with_center_in_pos
            (
                sout.str(),
                RED,
                T_col_row
                    (
                        CENTER_FIELD_COL,
                        CENTER_FIELD_ROW
                    )
            );
    }
    //-----------------------------------------------------------------------------------
    static void  make_pause_to_pressing_of_any_key()
    {
        _getch();
    }
    //-----------------------------------------------------------------------------------
    static T_col_row  get_rand_pos
        (
            int     left_col,
            int     right_col,
            int     top_row,
            int     botom_row
        )
    {
        int     rand_col    =   get_rand_val
                                    (
                                        left_col,
                                        right_col
                                    );
 
        int     rand_row    =   get_rand_val
                                    (
                                        top_row,
                                        botom_row
                                    );
 
        return  T_col_row
                    (
                        rand_col,
                        rand_row
                    );
    }
    //-----------------------------------------------------------------------------------
    static int  get_rand_val
        (
            int     min_val,
            int     max_val
        )
    {
        return  rand() % (max_val - min_val + 1) + min_val;
    }
    //-----------------------------------------------------------------------------------
    void  set_rand_apple_pos()
    {
        do
        {
            apple_pos_  =   get_rand_pos
                                (
                                    LEFT_FIELD_COL,
                                    RIGHT_FIELD_COL,
                                    TOP_FIELD_ROW,
                                    BOTTOM_FIELD_ROW
                                );
        }while  (
                        position_belongs_to_snake_body  ( apple_pos_    )
                    ||  position_belongs_to_border      ( apple_pos_    )
                );
    }
    //-----------------------------------------------------------------------------------
    bool  position_belongs_to_snake_body( const T_col_row&  pos )       const
    {
        return      std::find
                        (
                            snake_body_positions_deque_.begin   (),
                            snake_body_positions_deque_.end     (),
                            pos
                        )
 
                !=  snake_body_positions_deque_.end();
    }
    //-----------------------------------------------------------------------------------
    void  print_text_with_color_in_pos
        ( 
            const T_str&        text,
            T_color             color,
            const T_col_row&    pos
        )                                                               const
    {
 
        SetConsoleCursorPosition
            (
                hConsole_,
                pos
            );
 
        SetConsoleTextAttribute
            (
                hConsole_, 
                color
            );
 
        std::cout   <<  text;
 
        SetConsoleTextAttribute
            (
                hConsole_, 
                WHITE
            );
    }
    //-----------------------------------------------------------------------------------
    void  print_symb_with_color_in_pos
        (
            char                symb,
            T_color             color,
            const T_col_row&    pos
        )                                                               const
    {
        print_text_with_color_in_pos
            (
                T_str(1, symb),
                color,
                pos
            );
    }
    //-----------------------------------------------------------------------------------
    void  print_field_border()                                          const
    {
        for( int  row = TOP_FIELD_ROW; row <= BOTTOM_FIELD_ROW; ++row )
        {
            for( int  col = LEFT_FIELD_COL; col <= RIGHT_FIELD_COL; ++col )
            {
                T_col_row   cur_pos(col, row);
                if  (
                        position_belongs_to_border( cur_pos )
                    )
                {
                    print_border_symb_in_pos( cur_pos );
                }
            }//for
        }//for
    }
    //-----------------------------------------------------------------------------------
    void  print_border_symb_in_pos(const T_col_row&  pos)               const
    {
        print_symb_with_color_in_pos
            (
                BORDER_SYMB,
                BORDER_COLOR,
                pos
            );
    }
    //-----------------------------------------------------------------------------------
    void  print_text_with_color_with_center_in_pos
        ( 
            T_str       text,
            T_color     text_color,
            T_col_row   pos
        )                                                               const
    {
        int     text_left_col   =       pos.col_
 
                                    -       (
                                                text.size() - 1 
                                            )
                                        
                                        /   2;
 
        print_text_with_color_in_pos
            (
                text,
                text_color,
                T_col_row
                    (
                        text_left_col,
                        pos.row_
                    )
            );
    }
    //-----------------------------------------------------------------------------------
    void  print_info()                                                  const
    {
        int     cur_row     =   BOTTOM_FIELD_ROW + 1;
 
        print_text_with_color_in_pos(   "Управление:",      BLUE,   T_col_row(  CENTER_FIELD_COL,     cur_row )   );
 
        ++cur_row;
        print_symb_with_color_in_pos(   UPWARDS_ARROW,      GREEN,  T_col_row(  CENTER_FIELD_COL,     cur_row )   );
        print_text_with_color_in_pos(   "\t- вверх,",       BLUE,   T_col_row(  CENTER_FIELD_COL + 1, cur_row )   );
 
        ++cur_row;
        print_symb_with_color_in_pos(   DOWNWARDS_ARROW,    GREEN,  T_col_row(  CENTER_FIELD_COL,     cur_row )   );
        print_text_with_color_in_pos(   "\t- вниз,",        BLUE,   T_col_row(  CENTER_FIELD_COL + 1, cur_row )   );
 
        ++cur_row;
        print_symb_with_color_in_pos(   LEFTWARDS_ARROW,    GREEN,  T_col_row(  CENTER_FIELD_COL,     cur_row )   );
        print_text_with_color_in_pos(   "\t- влево,",       BLUE,   T_col_row(  CENTER_FIELD_COL + 1, cur_row )   );
 
        ++cur_row;
        print_symb_with_color_in_pos(   RIGHTWARDS_ARROW,   GREEN,  T_col_row(  CENTER_FIELD_COL,     cur_row )   );
        print_text_with_color_in_pos(   "\t- вправо,",      BLUE,   T_col_row(  CENTER_FIELD_COL + 1, cur_row )   );
 
        ++cur_row;
        print_text_with_color_in_pos(   "пробел",           GREEN,  T_col_row(  CENTER_FIELD_COL,     cur_row )   );
        print_text_with_color_in_pos(   "- пауза.",         BLUE,   T_col_row(  CENTER_FIELD_COL + 8, cur_row )   );
    }
    //-----------------------------------------------------------------------------------
    void  operated_eating_of_apples_before_collision_with_border_or_with_own_body()
    {
        for(;;)
        {
            //Пока ничего не нажато.
            while   (
                        !_kbhit()
                    )
            {
                print_speed_value                                       ();
                make_step_to_current_direction_and_to_eat_apple_if_got  ();
                Sleep                                                   ( millisec_per_step_ );
 
                if  (
                            is_collision_with_border    ()
                        ||  is_collision_with_own_body  ()
                    )
                {
                    return;
                }      
 
                if  (
                        is_collision_with_apple()
                    )
                {    
                    to_increase_speed       ();
                    draw_apple_in_rand_pos  ();
                }
            }            
            input_cur_control_key                                   ();
            set_pause_indicator_from_cur_conrol_key                 ();
            set_cur_direction_from_cur_conrol_key                   ();
            if_it_is_necessary_make_pause_to_pressing_of_any_key    ();
        }//for
    }
    //-----------------------------------------------------------------------------------
    void  print_speed_value()       const
    {
        std::ostringstream  sout;
        int     speed   =   round( 1000.0 / millisec_per_step_ );
        sout    <<  "Скорость "
                <<  speed
                <<  " символов в секунду.";
 
        print_text_with_color_with_center_in_pos
            (
                sout.str(),
                YELLOW,
                T_col_row
                    (
                        CENTER_FIELD_COL,
                        HEADLINE_ROW
                    )
            );
    }
    //-----------------------------------------------------------------------------------
    static int  round( double  x )
    {
        return  int(x + 0.5);
    }
    //-----------------------------------------------------------------------------------
    void  to_increase_speed()
    {
        double  k   =   0.2;
        millisec_per_step_  =   int
                                    (
                                            double( millisec_per_step_ )
                                        *   snake_body_positions_deque_.size()
                                        /   (
                                                    snake_body_positions_deque_.size()
                                                +   k
                                            )
                                    );
    }
    //-----------------------------------------------------------------------------------
    void  draw_apple_in_rand_pos()
    {
        set_rand_apple_pos();
 
        print_symb_with_color_in_pos
            (
                APPLE_SYMB,
                APPLE_COLOR,
                apple_pos_
            );
    }
    //-----------------------------------------------------------------------------------
    void  input_cur_control_key()
    {
        cur_conrol_key_     =   static_cast<T_conrol_key>
                                    (
                                        _getch()
                                    );
    }
    //-----------------------------------------------------------------------------------
    void  set_pause_indicator_from_cur_conrol_key()
    {
        if  (
                cur_conrol_key_     ==  PAUSE_KEY
            )
        {
            pause_indicator_    =   true;
        }
    }
    //-----------------------------------------------------------------------------------
    void  set_cur_direction_from_cur_conrol_key()
    {
        T_direction_of_key::const_iterator  key_direction_it    =   direction_of_key_.find( cur_conrol_key_ );
        if  ( 
                key_direction_it != direction_of_key_.end() 
            )
        {
            T_direction     new_direction   =   key_direction_it->second;
            if  (
                    !directions_are_opposite
                        (
                            cur_direction_,
                            new_direction
                        )
                )
            {
                cur_direction_  =   new_direction;
            }
        }
    }
    //-----------------------------------------------------------------------------------
    static bool  directions_are_opposite
        (
            T_direction     L,
            T_direction     R
        )
    {
        return          L   ==  LEFT_DIRECTION
                    &&  R   ==  RIGHT_DIRECTION
 
                ||      L   ==  RIGHT_DIRECTION
                    &&  R   ==  LEFT_DIRECTION
 
                ||      L   ==  UP_DIRECTION
                    &&  R   ==  DOWN_DIRECTION
 
                ||      L   ==  DOWN_DIRECTION
                    &&  R   ==  UP_DIRECTION;
    }
    //-----------------------------------------------------------------------------------
    void  if_it_is_necessary_make_pause_to_pressing_of_any_key()
    {
        if( pause_indicator_ )
        {
            _getch();
            pause_indicator_    =   false;
        }
    }
    //-----------------------------------------------------------------------------------
    void  make_step_to_current_direction_and_to_eat_apple_if_got()
    {
        T_col_row   old_head_pos    =   snake_body_positions_deque_.front   ();
        T_col_row   old_tail_pos    =   snake_body_positions_deque_.back    ();
        T_col_row   new_head_pos    =   old_head_pos;
 
        shift_position_in_direction
            (
                new_head_pos,
                cur_direction_
            );
 
        draw_head_in_pos        ( new_head_pos );
        draw_body_elem_in_pos   ( old_head_pos );
 
        snake_body_positions_deque_.push_front( new_head_pos );
 
        if( new_head_pos != apple_pos_ )
        {
            draw_field_elem_in_pos( old_tail_pos );
            snake_body_positions_deque_.pop_back();
        }
    }
    //-----------------------------------------------------------------------------------
    void  draw_head_in_pos( const T_col_row&  pos )         const
    {
        print_symb_with_color_in_pos
            (
                SNAKE_HEAD_SYMB,
                SNAKE_COLOR,
                pos
            );
    }
    //-----------------------------------------------------------------------------------
    void  draw_body_elem_in_pos( const T_col_row&  pos )    const
    {
        print_symb_with_color_in_pos
            (
                SNAKE_BODY_SYMB,
                SNAKE_COLOR,
                pos
            );
    }
    //-----------------------------------------------------------------------------------
    void  draw_field_elem_in_pos( const T_col_row&  pos )   const
    {
            print_symb_with_color_in_pos
                (
                    FIELD_SYMB,
                    WHITE,
                    pos
                );
    }
    //-----------------------------------------------------------------------------------
    static void  shift_position_in_direction
        (
            T_col_row&      pos,
            T_direction     direction
        )
    {
        switch( direction )
        {
        case LEFT_DIRECTION:
            pos.shift_to_left   ();
            break;
 
        case RIGHT_DIRECTION:
            pos.shift_to_right  ();
            break;
 
        case UP_DIRECTION:
            pos.shift_up        ();
            break;
 
        case DOWN_DIRECTION:
            pos.shift_down      ();
            break;
        }//switch
    }
    //-----------------------------------------------------------------------------------
    void  draw_snake_body()                 const
    {
        for (
                T_positions_deque::const_iterator
                snake_body_pos_it   =   snake_body_positions_deque_.begin   ();
                snake_body_pos_it   !=  snake_body_positions_deque_.end     ();
                ++snake_body_pos_it
            )
        {
            snake_body_pos_it == snake_body_positions_deque_.begin()
                ? draw_head_in_pos          ( *snake_body_pos_it )
                : draw_body_elem_in_pos     ( *snake_body_pos_it );
        }
    }
    //-----------------------------------------------------------------------------------
    bool  is_collision_with_border()        const
    {
        return  position_belongs_to_border
                    (
                        snake_body_positions_deque_.front()
                    );
    }
    //-----------------------------------------------------------------------------------
    static bool  position_belongs_to_border( const T_col_row&  pos )
    {
        return      pos.col_    ==  LEFT_FIELD_COL
                ||  pos.col_    ==  RIGHT_FIELD_COL
                ||  pos.row_    ==  TOP_FIELD_ROW
                ||  pos.row_    ==  BOTTOM_FIELD_ROW;
    }
    //-----------------------------------------------------------------------------------
    bool  is_collision_with_own_body()      const
    {
        T_positions_set     snake_body_positions_set
                                (
                                    snake_body_positions_deque_.begin   (),
                                    snake_body_positions_deque_.end     ()
                                );
 
        return  snake_body_positions_set.size() != snake_body_positions_deque_.size();
    }
    //-----------------------------------------------------------------------------------
    bool  is_collision_with_apple()         const
    {
        return  position_belongs_to_snake_body( apple_pos_ );
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
    srand(unsigned(time(0)));
    T_snake  snake;
    snake.play();
}
SAUtrade
13 / 13 / 1
Регистрация: 21.10.2012
Сообщений: 140
23.10.2012, 21:41     создание игры "Точки" #58
А кто нить писал морской бой? Как реализовываеться бой с компьютером и как сделать так чтобы поле созданное с помощью массива 10х10 было квадратным а не прямоугольным...
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
23.10.2012, 23:02     создание игры "Точки"
Еще ссылки по теме:

Создание объекта класса сразу после его описания (между "}" и ";") C++
C++ Создание 2D-игры для C++ "Волк-яйцелов"
C++ Создать классы "Computer", "Software", "User" и реализовать взаимодействие объектов этих типов между собой
C++ Найти угол одной точки "A" в соотношении к точке "B" в градусах
Ошибка "*.exe вызвал срабатывание точки останова" и "HEAP CORRUPTION" при вызове деструктора программой C++

Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
shalisan
3 / 3 / 1
Регистрация: 29.08.2012
Сообщений: 40
23.10.2012, 23:02     создание игры "Точки" #59
Цитата Сообщение от Mr.X Посмотреть сообщение
Ну, это на Си написано. На 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
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
/////////////////////////////////////////////////////////////////////////////////////////
#include <windows.h>
#include <conio.h>
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <iostream>
#include <map>
#include <set>
#include <sstream>
#include <string>
#include <utility>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string     T_str;
/////////////////////////////////////////////////////////////////////////////////////////
class  T_snake
{
    //-----------------------------------------------------------------------------------
    struct  T_col_row
    {
        int     col_;
        int     row_;
        //-------------------------------------------------------------------------------
        T_col_row
            (
                int     col     =   0,
                int     row     =   0
            )
            :
            col_    ( col ),
            row_    ( row )
        {}
        //-------------------------------------------------------------------------------
        bool  operator<(const T_col_row&  pos)  const
        {
            return      std::make_pair
                            (
                                col_,
                                row_
                            )
 
                    <   std::make_pair
                            (
                                pos.col_,
                                pos.row_
                            );
        }
        //-------------------------------------------------------------------------------
        bool  operator!=( T_col_row  pos )      const
        {
            return      *this   <   pos
                    ||  pos     <   *this;
        }
        //-------------------------------------------------------------------------------
        bool  operator==( T_col_row  pos )      const
        {
            return  !( *this    !=  pos );
        }
        //-------------------------------------------------------------------------------
        operator COORD()                        const
        {
            COORD   res =   {
                                col_,
                                row_
                            };
 
            return  res;
        }
        //-------------------------------------------------------------------------------
        void  shift_to_left     ()
        {
            --col_;
        }
        //-------------------------------------------------------------------------------
        void  shift_to_right    ()
        {
            ++col_;
        }
        //-------------------------------------------------------------------------------
        void  shift_up          ()
        {
            --row_;
        }
        //-------------------------------------------------------------------------------
        void  shift_down        ()
        {
            ++row_;
        }
        //-------------------------------------------------------------------------------
    };
    //-----------------------------------------------------------------------------------
    typedef std::deque  <T_col_row>   T_positions_deque;
    typedef std::set    <T_col_row>   T_positions_set;
    //-----------------------------------------------------------------------------------
    enum  T_direction
    {
        LEFT_DIRECTION,
        RIGHT_DIRECTION,
        UP_DIRECTION,
        DOWN_DIRECTION
    };
    //-----------------------------------------------------------------------------------
    enum  T_conrol_key
    {
        LEFT_DIR_KEY    =   75,
        RIGHT_DIR_KEY   =   77,
        UP_DIR_KEY      =   72,
        DOWN_DIR_KEY    =   80,
        PAUSE_KEY       =   ' '
    };
    //-----------------------------------------------------------------------------------
    enum  T_color
    {
        BLUE    =   9,
        GREEN   =   10,
        WHITE   =   11,
        RED     =   12,
        YELLOW  =   14
    };
    //-----------------------------------------------------------------------------------
    typedef std::map<T_conrol_key, T_direction>  T_direction_of_key;
    //-----------------------------------------------------------------------------------
    static const char       FIELD_SYMB                  =   ' ';
    static const char       BORDER_SYMB                 =   '#';
    static const char       SNAKE_HEAD_SYMB             =   1;
    static const char       SNAKE_BODY_SYMB             =   111;
    static const char       APPLE_SYMB                  =   4;
 
    static const char       UPWARDS_ARROW               =   24;
    static const char       DOWNWARDS_ARROW             =   25;
    static const char       RIGHTWARDS_ARROW            =   26;
    static const char       LEFTWARDS_ARROW             =   27;
 
    static const T_color    BORDER_COLOR                =   RED;
    static const T_color    APPLE_COLOR                 =   YELLOW;
    static const T_color    SNAKE_COLOR                 =   GREEN;
 
    static const int        FIELD_WIDTH                 =   80;
    static const int        FIELD_HIGHT                 =   20;
 
    static const int        LEFT_FIELD_COL              =   0;
    static const int        CENTER_FIELD_COL            =   LEFT_FIELD_COL  +   FIELD_WIDTH     /   2;
    static const int        RIGHT_FIELD_COL             =   LEFT_FIELD_COL  +   FIELD_WIDTH     -   1;
 
    static const int        HEADLINE_ROW                =   0;
 
    static const int        TOP_FIELD_ROW               =   1;
    static const int        CENTER_FIELD_ROW            =   TOP_FIELD_ROW   +   FIELD_HIGHT     /   2;
    static const int        BOTTOM_FIELD_ROW            =   TOP_FIELD_ROW   +   FIELD_HIGHT     -   1;
 
    static const int        START_MILLISEC_PER_STEP     =   100;
 
    static const size_t     START_SNAKE_LEN             =   6;
    //-----------------------------------------------------------------------------------
    bool                pause_indicator_;
    HANDLE              hConsole_;
    int                 millisec_per_step_;
 
    T_direction_of_key  direction_of_key_;
    T_positions_deque   snake_body_positions_deque_;
 
    T_col_row           apple_pos_;
    T_conrol_key        cur_conrol_key_;
    T_direction         cur_direction_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_snake()
        :
        pause_indicator_    ( false ),
        hConsole_
            (
                GetStdHandle( STD_OUTPUT_HANDLE )
            ),        
        millisec_per_step_  ( START_MILLISEC_PER_STEP )
        
    {
        direction_of_key_[ LEFT_DIR_KEY     ]   =   LEFT_DIRECTION;
        direction_of_key_[ RIGHT_DIR_KEY    ]   =   RIGHT_DIRECTION;
        direction_of_key_[ UP_DIR_KEY       ]   =   UP_DIRECTION;
        direction_of_key_[ DOWN_DIR_KEY     ]   =   DOWN_DIRECTION;
 
        make_start_snake_body   ();
        draw_snake_body         ();
        draw_apple_in_rand_pos  ();
    }
    //-----------------------------------------------------------------------------------
    void  make_start_snake_body()
    {
        cur_direction_  =   rand() % 2
                                ? RIGHT_DIRECTION
                                : LEFT_DIRECTION;
 
        T_col_row   cur_snake_body_pos
                        (
                            CENTER_FIELD_COL,
                            CENTER_FIELD_ROW
                        );
 
        for( int  i = 0; i < START_SNAKE_LEN; ++i )
        {
            snake_body_positions_deque_.push_front( cur_snake_body_pos );
 
            shift_position_in_direction
                (
                    cur_snake_body_pos,
                    cur_direction_
                );
        }
    }
    //-----------------------------------------------------------------------------------
    void  play()
    {
        print_field_border                                                          ();
        print_info                                                                  ();
        operated_eating_of_apples_before_collision_with_border_or_with_own_body     ();
        clear_screen                                                                ();
        print_result                                                                ();
        make_pause_to_pressing_of_any_key                                           ();
    }
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    static void  clear_screen()
    {
        system("cls");
    }
    //-----------------------------------------------------------------------------------
    void  print_result()    const
    {
        int     result  =   snake_body_positions_deque_.size() - START_SNAKE_LEN;
 
        std::ostringstream  sout;
        sout    <<  "Съедено яблок "
                <<  result
                <<  ".";
 
        print_text_with_color_with_center_in_pos
            (
                sout.str(),
                RED,
                T_col_row
                    (
                        CENTER_FIELD_COL,
                        CENTER_FIELD_ROW
                    )
            );
    }
    //-----------------------------------------------------------------------------------
    static void  make_pause_to_pressing_of_any_key()
    {
        _getch();
    }
    //-----------------------------------------------------------------------------------
    static T_col_row  get_rand_pos
        (
            int     left_col,
            int     right_col,
            int     top_row,
            int     botom_row
        )
    {
        int     rand_col    =   get_rand_val
                                    (
                                        left_col,
                                        right_col
                                    );
 
        int     rand_row    =   get_rand_val
                                    (
                                        top_row,
                                        botom_row
                                    );
 
        return  T_col_row
                    (
                        rand_col,
                        rand_row
                    );
    }
    //-----------------------------------------------------------------------------------
    static int  get_rand_val
        (
            int     min_val,
            int     max_val
        )
    {
        return  rand() % (max_val - min_val + 1) + min_val;
    }
    //-----------------------------------------------------------------------------------
    void  set_rand_apple_pos()
    {
        do
        {
            apple_pos_  =   get_rand_pos
                                (
                                    LEFT_FIELD_COL,
                                    RIGHT_FIELD_COL,
                                    TOP_FIELD_ROW,
                                    BOTTOM_FIELD_ROW
                                );
        }while  (
                        position_belongs_to_snake_body  ( apple_pos_    )
                    ||  position_belongs_to_border      ( apple_pos_    )
                );
    }
    //-----------------------------------------------------------------------------------
    bool  position_belongs_to_snake_body( const T_col_row&  pos )       const
    {
        return      std::find
                        (
                            snake_body_positions_deque_.begin   (),
                            snake_body_positions_deque_.end     (),
                            pos
                        )
 
                !=  snake_body_positions_deque_.end();
    }
    //-----------------------------------------------------------------------------------
    void  print_text_with_color_in_pos
        ( 
            const T_str&        text,
            T_color             color,
            const T_col_row&    pos
        )                                                               const
    {
 
        SetConsoleCursorPosition
            (
                hConsole_,
                pos
            );
 
        SetConsoleTextAttribute
            (
                hConsole_, 
                color
            );
 
        std::cout   <<  text;
 
        SetConsoleTextAttribute
            (
                hConsole_, 
                WHITE
            );
    }
    //-----------------------------------------------------------------------------------
    void  print_symb_with_color_in_pos
        (
            char                symb,
            T_color             color,
            const T_col_row&    pos
        )                                                               const
    {
        print_text_with_color_in_pos
            (
                T_str(1, symb),
                color,
                pos
            );
    }
    //-----------------------------------------------------------------------------------
    void  print_field_border()                                          const
    {
        for( int  row = TOP_FIELD_ROW; row <= BOTTOM_FIELD_ROW; ++row )
        {
            for( int  col = LEFT_FIELD_COL; col <= RIGHT_FIELD_COL; ++col )
            {
                T_col_row   cur_pos(col, row);
                if  (
                        position_belongs_to_border( cur_pos )
                    )
                {
                    print_border_symb_in_pos( cur_pos );
                }
            }//for
        }//for
    }
    //-----------------------------------------------------------------------------------
    void  print_border_symb_in_pos(const T_col_row&  pos)               const
    {
        print_symb_with_color_in_pos
            (
                BORDER_SYMB,
                BORDER_COLOR,
                pos
            );
    }
    //-----------------------------------------------------------------------------------
    void  print_text_with_color_with_center_in_pos
        ( 
            T_str       text,
            T_color     text_color,
            T_col_row   pos
        )                                                               const
    {
        int     text_left_col   =       pos.col_
 
                                    -       (
                                                text.size() - 1 
                                            )
                                        
                                        /   2;
 
        print_text_with_color_in_pos
            (
                text,
                text_color,
                T_col_row
                    (
                        text_left_col,
                        pos.row_
                    )
            );
    }
    //-----------------------------------------------------------------------------------
    void  print_info()                                                  const
    {
        int     cur_row     =   BOTTOM_FIELD_ROW + 1;
 
        print_text_with_color_in_pos(   "Управление:",      BLUE,   T_col_row(  CENTER_FIELD_COL,     cur_row )   );
 
        ++cur_row;
        print_symb_with_color_in_pos(   UPWARDS_ARROW,      GREEN,  T_col_row(  CENTER_FIELD_COL,     cur_row )   );
        print_text_with_color_in_pos(   "\t- вверх,",       BLUE,   T_col_row(  CENTER_FIELD_COL + 1, cur_row )   );
 
        ++cur_row;
        print_symb_with_color_in_pos(   DOWNWARDS_ARROW,    GREEN,  T_col_row(  CENTER_FIELD_COL,     cur_row )   );
        print_text_with_color_in_pos(   "\t- вниз,",        BLUE,   T_col_row(  CENTER_FIELD_COL + 1, cur_row )   );
 
        ++cur_row;
        print_symb_with_color_in_pos(   LEFTWARDS_ARROW,    GREEN,  T_col_row(  CENTER_FIELD_COL,     cur_row )   );
        print_text_with_color_in_pos(   "\t- влево,",       BLUE,   T_col_row(  CENTER_FIELD_COL + 1, cur_row )   );
 
        ++cur_row;
        print_symb_with_color_in_pos(   RIGHTWARDS_ARROW,   GREEN,  T_col_row(  CENTER_FIELD_COL,     cur_row )   );
        print_text_with_color_in_pos(   "\t- вправо,",      BLUE,   T_col_row(  CENTER_FIELD_COL + 1, cur_row )   );
 
        ++cur_row;
        print_text_with_color_in_pos(   "пробел",           GREEN,  T_col_row(  CENTER_FIELD_COL,     cur_row )   );
        print_text_with_color_in_pos(   "- пауза.",         BLUE,   T_col_row(  CENTER_FIELD_COL + 8, cur_row )   );
    }
    //-----------------------------------------------------------------------------------
    void  operated_eating_of_apples_before_collision_with_border_or_with_own_body()
    {
        for(;;)
        {
            //Пока ничего не нажато.
            while   (
                        !_kbhit()
                    )
            {
                print_speed_value                                       ();
                make_step_to_current_direction_and_to_eat_apple_if_got  ();
                Sleep                                                   ( millisec_per_step_ );
 
                if  (
                            is_collision_with_border    ()
                        ||  is_collision_with_own_body  ()
                    )
                {
                    return;
                }      
 
                if  (
                        is_collision_with_apple()
                    )
                {    
                    to_increase_speed       ();
                    draw_apple_in_rand_pos  ();
                }
            }            
            input_cur_control_key                                   ();
            set_pause_indicator_from_cur_conrol_key                 ();
            set_cur_direction_from_cur_conrol_key                   ();
            if_it_is_necessary_make_pause_to_pressing_of_any_key    ();
        }//for
    }
    //-----------------------------------------------------------------------------------
    void  print_speed_value()       const
    {
        std::ostringstream  sout;
        int     speed   =   round( 1000.0 / millisec_per_step_ );
        sout    <<  "Скорость "
                <<  speed
                <<  " символов в секунду.";
 
        print_text_with_color_with_center_in_pos
            (
                sout.str(),
                YELLOW,
                T_col_row
                    (
                        CENTER_FIELD_COL,
                        HEADLINE_ROW
                    )
            );
    }
    //-----------------------------------------------------------------------------------
    static int  round( double  x )
    {
        return  int(x + 0.5);
    }
    //-----------------------------------------------------------------------------------
    void  to_increase_speed()
    {
        double  k   =   0.2;
        millisec_per_step_  =   int
                                    (
                                            double( millisec_per_step_ )
                                        *   snake_body_positions_deque_.size()
                                        /   (
                                                    snake_body_positions_deque_.size()
                                                +   k
                                            )
                                    );
    }
    //-----------------------------------------------------------------------------------
    void  draw_apple_in_rand_pos()
    {
        set_rand_apple_pos();
 
        print_symb_with_color_in_pos
            (
                APPLE_SYMB,
                APPLE_COLOR,
                apple_pos_
            );
    }
    //-----------------------------------------------------------------------------------
    void  input_cur_control_key()
    {
        cur_conrol_key_     =   static_cast<T_conrol_key>
                                    (
                                        _getch()
                                    );
    }
    //-----------------------------------------------------------------------------------
    void  set_pause_indicator_from_cur_conrol_key()
    {
        if  (
                cur_conrol_key_     ==  PAUSE_KEY
            )
        {
            pause_indicator_    =   true;
        }
    }
    //-----------------------------------------------------------------------------------
    void  set_cur_direction_from_cur_conrol_key()
    {
        T_direction_of_key::const_iterator  key_direction_it    =   direction_of_key_.find( cur_conrol_key_ );
        if  ( 
                key_direction_it != direction_of_key_.end() 
            )
        {
            T_direction     new_direction   =   key_direction_it->second;
            if  (
                    !directions_are_opposite
                        (
                            cur_direction_,
                            new_direction
                        )
                )
            {
                cur_direction_  =   new_direction;
            }
        }
    }
    //-----------------------------------------------------------------------------------
    static bool  directions_are_opposite
        (
            T_direction     L,
            T_direction     R
        )
    {
        return          L   ==  LEFT_DIRECTION
                    &&  R   ==  RIGHT_DIRECTION
 
                ||      L   ==  RIGHT_DIRECTION
                    &&  R   ==  LEFT_DIRECTION
 
                ||      L   ==  UP_DIRECTION
                    &&  R   ==  DOWN_DIRECTION
 
                ||      L   ==  DOWN_DIRECTION
                    &&  R   ==  UP_DIRECTION;
    }
    //-----------------------------------------------------------------------------------
    void  if_it_is_necessary_make_pause_to_pressing_of_any_key()
    {
        if( pause_indicator_ )
        {
            _getch();
            pause_indicator_    =   false;
        }
    }
    //-----------------------------------------------------------------------------------
    void  make_step_to_current_direction_and_to_eat_apple_if_got()
    {
        T_col_row   old_head_pos    =   snake_body_positions_deque_.front   ();
        T_col_row   old_tail_pos    =   snake_body_positions_deque_.back    ();
        T_col_row   new_head_pos    =   old_head_pos;
 
        shift_position_in_direction
            (
                new_head_pos,
                cur_direction_
            );
 
        draw_head_in_pos        ( new_head_pos );
        draw_body_elem_in_pos   ( old_head_pos );
 
        snake_body_positions_deque_.push_front( new_head_pos );
 
        if( new_head_pos != apple_pos_ )
        {
            draw_field_elem_in_pos( old_tail_pos );
            snake_body_positions_deque_.pop_back();
        }
    }
    //-----------------------------------------------------------------------------------
    void  draw_head_in_pos( const T_col_row&  pos )         const
    {
        print_symb_with_color_in_pos
            (
                SNAKE_HEAD_SYMB,
                SNAKE_COLOR,
                pos
            );
    }
    //-----------------------------------------------------------------------------------
    void  draw_body_elem_in_pos( const T_col_row&  pos )    const
    {
        print_symb_with_color_in_pos
            (
                SNAKE_BODY_SYMB,
                SNAKE_COLOR,
                pos
            );
    }
    //-----------------------------------------------------------------------------------
    void  draw_field_elem_in_pos( const T_col_row&  pos )   const
    {
            print_symb_with_color_in_pos
                (
                    FIELD_SYMB,
                    WHITE,
                    pos
                );
    }
    //-----------------------------------------------------------------------------------
    static void  shift_position_in_direction
        (
            T_col_row&      pos,
            T_direction     direction
        )
    {
        switch( direction )
        {
        case LEFT_DIRECTION:
            pos.shift_to_left   ();
            break;
 
        case RIGHT_DIRECTION:
            pos.shift_to_right  ();
            break;
 
        case UP_DIRECTION:
            pos.shift_up        ();
            break;
 
        case DOWN_DIRECTION:
            pos.shift_down      ();
            break;
        }//switch
    }
    //-----------------------------------------------------------------------------------
    void  draw_snake_body()                 const
    {
        for (
                T_positions_deque::const_iterator
                snake_body_pos_it   =   snake_body_positions_deque_.begin   ();
                snake_body_pos_it   !=  snake_body_positions_deque_.end     ();
                ++snake_body_pos_it
            )
        {
            snake_body_pos_it == snake_body_positions_deque_.begin()
                ? draw_head_in_pos          ( *snake_body_pos_it )
                : draw_body_elem_in_pos     ( *snake_body_pos_it );
        }
    }
    //-----------------------------------------------------------------------------------
    bool  is_collision_with_border()        const
    {
        return  position_belongs_to_border
                    (
                        snake_body_positions_deque_.front()
                    );
    }
    //-----------------------------------------------------------------------------------
    static bool  position_belongs_to_border( const T_col_row&  pos )
    {
        return      pos.col_    ==  LEFT_FIELD_COL
                ||  pos.col_    ==  RIGHT_FIELD_COL
                ||  pos.row_    ==  TOP_FIELD_ROW
                ||  pos.row_    ==  BOTTOM_FIELD_ROW;
    }
    //-----------------------------------------------------------------------------------
    bool  is_collision_with_own_body()      const
    {
        T_positions_set     snake_body_positions_set
                                (
                                    snake_body_positions_deque_.begin   (),
                                    snake_body_positions_deque_.end     ()
                                );
 
        return  snake_body_positions_set.size() != snake_body_positions_deque_.size();
    }
    //-----------------------------------------------------------------------------------
    bool  is_collision_with_apple()         const
    {
        return  position_belongs_to_snake_body( apple_pos_ );
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
    srand(unsigned(time(0)));
    T_snake  snake;
    snake.play();
}
большое спасибо за ответ но я начал познавать ActionScript 3.0 =)
Yandex
Объявления
23.10.2012, 23:02     создание игры "Точки"
Ответ Создать тему
Опции темы

Текущее время: 05:31. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru