dummy2d устарел, попробуйте jdummy2d:
http://jdummy2d.sourceforge.net/
ВНИМАНИЕ! ЭТОТ README-ФАЙЛ ВСЕГДА СВЕЖЕЕ ЧЕМ ТОТ, ЧТО В АРХИВЕ!
SORRY, ONLY RUSSIAN REAMDE CURRENTLY AVAILABLE.
================================================
dummy2d (далее просто DUMMY)
- простой язык программирования для 2D игр
================================================
версия за август 2012. автор - jabberx
================================================
https://sourceforge.net/projects/dummy2d/
dummy2d (DUMMY) полностью бесплатен для коммерческого
и некоммерческого использования
если есть вопросы - регистрируйтесь на sourceforge
и пишите в Wiki
================================================
Здравствуй, дорогой русский создатель игр.
Ты скачал лучший на свете язык программирования. Он не такой как все. Все языки программирования сложные и запутанные, а этот простой. Но вместе с тем он довольно мощный и быстрый. С его помощью ты легко сделаешь игру (двухмерную). Ты научишься рисовать линии, прямоугольники, круги, выводить в окно текст, изображения или часть изображения, проигрывать звуки, проверять состояния клавиш и манипулятора "мышь".
Надеюсь, ты распаковал этот архив на диск Эс. Это самый надежный диск, потому что он системный. Путь должен быть таким: C:\DUMMY\. В папке DUMMY должны быть папки data, dlls и example (пример игры - понг). Но если ты распаковал на другой диск или в другой путь, ничего - просто придется внимательно подредактировать make.bat и всё будет хорошо.
==========================================
ДЛЯ НАЧАЛА
==========================================
Тебе надо создать файл main.txt, положить рядом с ним make.bat (найдешь в папке C:\DUMMY\example-tetris или в любой другой папке с примером. Примеров, кстати аж 6 штук!). Береги этот файл (речь о make.bat). Он тебе понадобится. Создай рядом папку data и клади в неё свои картинки, шрифты, звуки. Когда напишешь свою программу, запустишь make.bat и если не будет никаких ошибок, то окошко будет пустым. Если будут ошибки, ты увидишь номер строчки с ошибкой. В папке data ( там будет много всяких файлов, не пугайся ) тебе нужен GAME.exe. Ты можешь запустить и run.bat, который появится после успешной компиляции, но тогда на фоне будет висеть черное окошко. Поэтому лучше перейди в папку data и запусти GAME.exe. Это твоя игра. Но учти, чтобы распространять игру, тебе нужно будет упаковать всю папку data в архив. Некоторые dll можешь перед запаковкой удалить, например libpng (если не загружаешь png файлы), vorbis и ogg (если не играешь ogg), smpeg (если не играешь mp3), mikmod (если не играешь трекерную музыку). Остальные лучше не трогать. В папке data твоей игры должен лежать default.ttf - это дефолтный шрифт. Его можешь заменить на другой, но не удаляй.
В начале своей программы напиши строчку:
#include <DUMMY>
Инклудэ это мощная команда макропроцессора компьютерных команд. Ты можешь написать #include "kusok.txt" в любом месте своей программы и код из kusok.txt встроится на то место. Это называется модульность. Модульность нужна чтобы код не превращался в спагетти.
После того как ты написал строчку #include <DUMMY>, начинай писать саму программу. Каждая новая строчка должна начинаться со знака доллара. Затем делай отступы. Хотя бы один пробел. Отступы делаются для удобства чтения.
$ WAIT(1000)
$ END
Это простейшая программа, состоящая из трех строчек. Она создаёт пустое окно и показывает его в течение секунды. #include <DUMMY> вначале и END в конце - это обязательные команды твоей программы.
Ширина и высота окна задается по желанию один раз, перед #include <DUMMY>:
#define WWIDTH 1024
#define WHEIGHT 768
#include <DUMMY>
$ WAIT(1000)
$ END
Для того, чтобы игра запускалась в полноэкранном режиме, нужно добавить команду #define FULLSCREEN
#define FULLSCREEN
#define WWIDTH 1024
#define WHEIGHT 768
#include <DUMMY>
$ WAIT(1000)
$ END
По умолчанию окно имеет размеры 640 на 480. Переключиться в полноэкранный режим и обратно можно в любой момент в программе с помощью команды TOGGLE.
Типичная программа с пустым игровым циклом выглядит так:
#include <DUMMY>
$ INT VAR1 // инициализация переменных
$ RESETGAME:
$ VAR1 = 0 // очистка переменных
$ GOTO(START)
$ LOGIC: // в этом блоке для любых передвижений ит.п. разумно использовать DELTA (величина в мс, обычно около 17)
$ IF(KEY[ESCAPE]) THEN
$ EXIT
$ ENDIF
$ RETURN
$ RENDER:
$ CLS(BLACK) // очистка экрана и позиции текстового курсора
// здесь начинается отрисовка
$ PRINT("Hello!")
// здесь кончается отрисовка
$ UPDATE // показ всего, что нарисовали в один момент
$ RETURN
$ START:
$ INPUT // получение ввода (без этого проверка кнопок не будет работать
// и вообще INPUT - в игровом цикле обязательная вещь,
// даже в скринсейвере где вы не принимаете никакого ввода)
$ GETDELTA // рассчет DELTA (также требуется для работы CAPFPS)
$ GOSUB(LOGIC)
$ GOSUB(RENDER)
$ CAPFPS(60) // ограничение скорости кадров (для экономии энергии)
// в особо динамичных играх возможно лучше ставить 120
// сделайте 120 в example-shmup (потому что я забыл и оставил 60)
$ GOTO(START)
$ END
Распространяя игру не забудь удалить make.bat из архива с игрой, т.к. некоторые могут случайно запустить его и удалить исполняемый файл игры.
Для распространения игры можешь использовать запаковщик-установщик типа InnoSetup. В этом случае никакие батники или лазанья среди кучи файлов в поисках GAME.exe игроку не понадобятся.
==========================================
О СРЕДЕ РАЗРАБОТКИ
==========================================
Ты можешь писать свою программу в обычном блокноте. Да! Невероятно, но DUMMY не требует каких-то хитромудрых "СТУДИЙ". Хорошим выбором будет Notepad++. Можно также писать в Microsoft Office Excel (если ты хорошо им владеешь, то тебе будет удобнее, чем в блокноте). Во многих текстовых редакторах есть подсветка синтаксиса и автодополнения. Если захочешь настроить свои - в папке DUMMY есть keywords.txt (ключевые слова для подсветки) и autocomplete (ключевые слова для автодополнения в формате xml, подойдут для notepad++). Если не хочешь возиться с настройкой - поставь любой похожий синтаксис, например Smalltalk.
==========================================
А ТЕПЕРЬ ПОДРОБНЕЕ ОБО ВСЕХ ВСЕХ КОМАНДАХ:
==========================================
Главное
-------
WW - ИСПОЛЬЗУЕТСЯ ДЛЯ _ПОЛУЧЕНИЯ_ ШИРИНЫ ОКНА. СОКРАЩЕНИЕ ДЛЯ WWIDTH
WH - ТО ЖЕ САМОЕ ДЛЯ ВЫСОТЫ
TITLE("..") - ЗАДАЁТ ЗАГОЛОВОК ОКНУ
SHOWFPS - показать текущую скорость кадров в заголовке. использовать после GETDELTA
TOGGLE - КОМАНДА ПЕРЕКЛЮЧЕНИЯ МЕЖДУ ОКОННЫМ И ПОЛНОЭКРАННЫМ РЕЖИМОМ
CLEAR(c) - ОЧИСТИТЬ ОКНО. УДАЛИТЬ ВСЁ НАРИСОВАННОЕ. CLEAR(RED) ОЧИСТИТ КРАСНЫМ ЦВЕТОМ. ПРОСТО CLEAR() - ЧЕРНЫМ
CLS(c) - ОЧИСТИТЬ ОКНО ЗАДАННЫМ ЦВЕТОМ И УСТАНОВИТЬ (LOCATE) ТЕКСТОВЫЙ КУРСОР В ПОЗИЦИЮ 0,0
UPDATE - ОБНОВИТЬ ОКНО. ВСЁ, ЧТО БЫЛО НАРИСОВАНО - ПОКАЖЕТСЯ В ОКНЕ.
BEGIN - НАЧАЛО ЛОКАЛЬНОЙ ОБЛАСТИ. ЧТОБЫ НЕ СОРИТЬ: ВСЕ ПЕРМЕННЫЕ, СОЗДАННЫЕ В ЛОКАЛЬНОЙ ОБЛАСТИ БУДУТ ДОСТУПНЫ ТОЛЬКО В НЕЙ.
END - КОНЕЦ ЛОКАЛЬНОЙ ОБЛАСТИ. ТАКЖЕ СТАВИТСЯ В САМОМ КОНЦЕ ПРОГРАММЫ. НЕ ПУТАТЬ С ВЫХОДОМ ИЗ ПРОГРАММЫ. ВЫХОД ЭТО EXIT
EXIT - НЕМЕДЛЕННЫЙ ВЫХОД ИЗ ПРОГРАММЫ.
GOTO(label) - ПРЫГНУТЬ НА МЕТКУ. ВЕРНУТЬСЯ БУДЕТ НЕЛЬЗЯ. GOTO(METKA)
ПРИМЕЧАНИЕ: метки делаются так $ METKA:
GOSUB(label) - ИДТИ НА МЕТКУ С ВОЗМОЖНОСТЬЮ ВОЗВРАТА. GOSUB(METKA)
RETURN - ВОЗВРАТИТЬСЯ ТУДА, ОТКУДА ПРИШЕЛ
JUMP(условие,метка) - ПРЫГНУТЬ НА МЕТКУ, ЕСЛИ УСЛОВИЕ ВЫПОЛНЯЕТСЯ
RJUMP(условие,метка) - ИДТИ НА МЕТКУ С ВОЗМОЖНОСТЬЮ ВОЗВРАТА, ЕСЛИ УСЛОВИЕ ВЫПОЛНЯЕТСЯ
Изображения
------------
IMAGE name ( "filename" ) - ЗАГРУЖАЕТ КАРТИНКУ. IMAGE KARTINKA1 ( "TEST.BMP", 1 ) 1 ЗНАЧИТ ЧТО РОЗОВОГО ЦВЕТА НЕ БУДЕТ
SETPOINT(x,y,color) - УСТАНАВЛИВАЕТ ТОЧКУ В КАРТИНКЕ. KARTINKA1.SETPOINT ( 10,10,RED)
GETPOINT(x,y) - ВЗЯТИЕ ТОЧКИ ИЗ КАРТИНКИ ULONG TZVET = KARTINKA1.GETPOINT (X,Y)
WIDTH - ШИРИНА КАРТИНКИ KARTINKA1.WIDTH
HEIGHT - ВЫСОТА КАРТИНКИ.
DRAW(...) - РИСОВАТЬ КАРТИНКУ ИЛИ ШРИФТ. KARTINKA1.DRAW(X,Y) ИЛИ KARTINKA1.DRAW(X,Y,CX,CY,CW,CH) ДЛЯ ЧАСТИЧНОЙ ОТРИСОВКИ
SETALPHA(n) - устанавливает прозрачность изображению от 0 (прозрачный) до 255 (непрозрачный). $ KARTINKA1.SETALPHA(128)
SCALE(x) - масштабирует картинку на целую степень. не использовать много раз, иначе память всю съедите. $ KARTINKA1.SCALE(2.0f) х2 $ KARTINKA1.SCALE(0.5f) /2
ROTATE(a) - поворачивает картинку на ПРЯМОЙ угол. тоже часто не используйте. создали - повернули и пользуйтесь. $ KARTINKA1.ROTATE(270) $ KARTINKA1.ROTATE (-90)
FLIPV() - отразить по вертикали. KARTINKA1.FLIPV(). тоже часто не использовать
FLIPH() - отразить по горизонтали. KARTINKA1.FLIPH(). тоже часто не использовать
SAVEBMP(картинка,имя файла)
RIMAGE name ( "filename" ) - другой тип картинки. объявлением похож на IMAGE. но после объявления можно сделать просчет поворотов с некоторой точностью. перед просчетом рекомендуется увеличить картинку вдвое чтобы пиксели не "поехали".
PRECACHE(n) - просчет поворотов. $ RIMAGE tank ( "tank.png" ) $ tank.PRECACHE ( 10 ) $ - будет создано 36 поворотов (360/10). Чем меньше число точности, тем больше памяти и времени займет просчет поворотов.
Рисование RIMAGE также отличается от IMAGE. SETALPHA для RIMAGE не работает. Вот как рисуется RIMAGE:
tank.DRAW(x,y,angle) или tank.DRAW(x,y,angle,alpha). Angle это угол в градусах. Будет выбрано изображение с ближайшим доступным просчитанным углом.
Файлы
------
FILEWRITER name ( "filename" ) - СОЗДАЁТ ФАЙЛОВОГО ПИСАТЕЛЯ. FILEWRITER FP1 ( "TEST.TXT" )
FILEREADER name ( "filename" ) - СОЗДАЁТ ФАЙЛОВОГО ЧИТАТЕЛЯ. FILEREADER FCHI1 ( "TEST.TXT" )
OPEN("filename") - ЕСЛИ ФАЙЛОВЫЙ НЕ ИНИЦИАЛИЗИРОВАН, МОЖНО ОТКРЫТЬ ПОЗЖЕ. FP1.OPEN ( "TEST.TXT" )
CLOSE() - ЗАКРЫТИЕ ФАЙЛОВОГО. FP1.CLOSE()
WRITE(file,data) - ПИСАТЬ В ФАЙЛ. WRITE(FP1,"TEST")
READ(file,var) - ЧИТАТЬ ИЗ ФАЙЛА В ПЕРЕМЕННУЮ. $ STRING S $ READ(FCHI1, S)
ПРИМЕЧАНИЕ: при записи в файл добавляйте '\n' между переменными, чтобы потом можно было прочитать их по очереди
Разное
------
CONVERT(A,B) - ПЕРЕВОДИТ ВЕЛИЧИНЫ ИЗ ПЕРВОЙ ВО ВТОРУЮ. $ STRING S $ INT X = 5 $ CONVERT(X,S). В S БУДЕТ "5"
RANDOMIZE() - МЕШАТЬ СЛУЧАЙНЫЕ ЦИФРЫ СЛУЧАЙНЫМ ОБРАЗОМ, ЧТОБЫ БЫЛО СЛУЧАЙНЕЙ. НО МОЖНО И ПЕРЕДАТЬ ЗЕРНО RANDOMIZE(4)
RANDOM - ВЫДАТЬ СЛУЧАЙНОЕ ЧИСЛО. INT R = RANDOM(10) В ЧИСЛЕ R БУДЕТ ЧИСЛО ОТ 0 ДО 9
Есть еще математические функции, они будут рассмотрены ниже.
SYSTEM ("..команда..") - выполнить системную команду. calc, например, запустит калькулятор
VAL(S) - ВОЗВРАЩАЕТ ЧИСЛОВОЕ ЗНАЧЕНИЕ СТРОКИ
DVAL(S) - ВОЗВРАЩАЕТ ЧИСЛОВОЕ ЗНАЧЕНИЕ СТРОКИ (ЧИСЛО С ПЛАВАЮЩЕЙ ТОЧКОЙ)
TXT(V) - ВОЗВРАЩАЕТ СТРОКОВОЕ ЗНАЧЕНИЕ ИЗ ЧИСЛА
PUSH, POP, а также эти команды с приставками I, UI, L, UL, F, D см ниже в приложении "СТЕК"
MOD - возвращает число без знака
SETCURSORPOS(х,у) - устанавливает позицию курсора
HIDECURSOR - прячет курсор
SHOWCURSOR - показывает курсор
Шрифты
------
FONT name ( "filename", size) - ЗАГРУЖАЕТ ШРИФТ. FONT shrift1 ( "TEST.TTF", 16 ). 16 - РАЗМЕР В ПИКСЕЛЯХ.
ПРИНИМАЮТСЯ ТОЛЬКО TTF. РИСУЕТСЯ ШРИФТ ТАК: shrift1.DRAW ( x,y,message,color)
Шрифты можно взять в папке WINDOWS.
Для удобства существуют также команды PRINT и LOCATE
PRINT(текст) печатает текст шрифтом default.ttf из папки дата и переводит строку
команда IPRINT(число) эквивалентна PRINT(TXT(число))
перед #include <DUMMY> надо указать #define FONTSIZE N, где N - желаемый размер шрифта
цвет текста же можно менять в любом месте программы:
TEXTCOLOR = RED
LOCATE(X,Y) - устанавливает точку, с которой будет печататься следующий текст по команде PRINT
Графика
-------
LINE(...) - РИСОВАТЬ ЛИНИЮ. LINE (X1,Y1,X2,Y2,ЦВЕТ). ЦВЕТА СМ. НИЖЕ
CIRCLE(...) - РИСОВАТЬ КРУГ. CIRCLE (X,Y,РАДИУС,ЦВЕТ)
RECT(...) - РИСОВАТЬ ПРЯМОУГОЛЬНИК. RECT (X,Y,ШИРИНА,ВЫСОТА,ТОЛЩИНА,ЦВЕТ)
FCIRCLE(...) - ЗАКРАШЕННЫЙ КРУГ.
FRECT(...) - ЗАКРАШЕННЫЙ ПРЯМОУГОЛЬНИК. !В ОТЛИЧИЕ ОТ ПРОСТОГО, ТОЛЩИНА ЛИНИИ ЗДЕСЬ НЕ ПЕРЕДАЕТСЯ!
GETPIXEL(X,Y) - получает цвет пикселя из окна
SETPIXEL(X,Y,C) - устанавливает цвет пикселя в окне.
Внимание! При попытке сделать SET/GET PIXEL с неверными координатами (меньше нуля или больше размеров окна) программа вылетит. Делайте проверку сами, если надо. Встроенной проверки нет во имя производительности.
Тайминг
-------
WAIT(N) - ЖДАТЬ N МИЛЛИСЕКУНД. WAIT(500) - ПОДОЖДЕТ ПОЛСЕКУНДЫ. ИСПОЛЬЗУЙТЕ НЕБОЛЬШИЕ ЗНАЧЕНИЯ В ЦИКЛАХ, ЧТОБЫ РАЗГРУЗИТЬ CPU
DELAY(N) - ЖДАТЬ N МИЛЛИСЕКУНД. ПРИ ЭТОМ DELTA не будет расти, в отличие от WAIT. Точность до 10 мс.
DELTA - встроенная переменная, хранящая время в миллисекундах прошедшее с прошлого вызова команды GETDELTA
GETDELTA - получает новую дельту. делает возможным использование функции CAPFPS(n). использовать в начале цикла.
CAPFPS(fps) - использовать в конце цикла, чтобы подождать ровно столько, чтобы FPS был равен определенному числу. $ CAPFPS(60)
Ввод
----
INPUT - ПРИНЯТЬ ВВОД - УЗНАТЬ КАКАЯ КЛАВИША НАЖАТА ИТП
KEY(..) - ЕСЛИ ВЫЗЫВАЛСЯ ВВОД, МОЖНО УЗНАТЬ НАЖАТА ЛИ КЛАВИША. KEY(ENTER) БУДЕТ РАВНЯТЬСЯ 1/TRUE ЕСЛИ НАЖАТ ENTER. Для проверки можно использовать и KEY[..]. Можно обнулить флаг нажатой клавиши: KEY[ENTER]=false
BUTTON(..) - ПОХОЖИМ ОБРАЗОМ ПОСЛЕ ПОЛУЧЕНИЯ ВВОДА МОЖНО УЗНАТЬ О СОСТОЯНИИ КНОПОК МЫШИ. НАЗВАНИЯ ВСЕХ КНОПОК СМ. НИЖЕ
MOUSEX - А ТАКЖЕ КООРДИНАТЫ МЫШИ ПО ОСИ АБСЦИССЫ
MOUSEY - И ОРДИНАТЫ
Звуки
-----
SOUND name ( "filename" ) - ЗАГРУЖАЕТ ЗВУК. SOUND ZVUK1 ( "TEST.WAV" )
PLAY() - ИГРАТЬ ЗВУК. ZVUK1.PLAY(). ZVUK1.PLAY(leftvolume,rightvolume,channel)
STOP() - ОСТАНОВИТЬ ЗВУК. ZVUK1.STOP(). Доступно только если указывалась громкость и канал. каналов всего 8 (0-7). -1 - любой доступный канал
LOOP(leftvol,rightvol,channel) - ЗАЦИКЛИТЬ ЗВУК.
STOPSOUNDS - глобально останавливает все звуки.
Музыка:
-------
MUSIC name = LOADMUSIC ( "filename" )
Поддерживаются форматы wav, ogg, mp3, трекерная музыка. формат вроде бы 44100 16 бит
PLAYMUSIC(name) - начинает играть музыку
STOPMUSIC - глобально останавливает музыку
PAUSEMUSIC - глобально ПРИостанавливает музыку
RESUMEMUSIC - продолжает приостановленную музыку
ОПЕРАТОРЫ ВЕТВЛЕНИЯ
-------------------
===
IF:
===
Пример программы, использующей IF. Поиграйтесь со значениями A и B
#include <DUMMY>
$ FONT FONT1 ( "test.ttf", 16 )
$ INT A = 5, B = 7
$ IF (A > B) THEN
$ FONT1.DRAW (0,0,"A bolshe B",RED)
$ ELSEIF (A >= B ) THEN
$ FONT1.DRAW (0,0,"A bolshe ili ravno B",RED)
$ ELSE
$ FONT1.DRAW (0,0,"A menshe B",RED)
$ ENDIF
$ UPDATE
$ WAIT(1000)
$ END
Запомните, что == это оператор сравнения, а = - оператор присваивания. Другие операторы сравнений: != (не равно), >, >=, <, <=.
Можно объединять несколько условий с помощью операторов AND, OR и NOT
$ IF (A>B OR A==B) THEN
$ FONT1.DRAW (0,0,"A bolshe B",RED)
$ ENDIF
Есть еще тернарный оператор
условие ? действияесливыполняется : действияеслиНЕвыполняется
$ (A>B OR A==B) ? FONT1.DRAW (0,0,"A bolshe B",RED) : 0 //0 - значит ничего не делать
Мы избавились от назойливых функций, классов и прочей ереси из мира ООП. Но осталось одно зло - циклы. Будьте осторожны, старайтесь использовать GOTO(метка), GOSUB(метка) и RETURN там где можно. Там где не получается - используйте следующие конструкции:
====
FOR:
====
$ FOR (INT I=0;I<10;I++)
$ .....действия.....
$ NEXT
Пример (с предположением, что макрос PRINT определен, про МАКРОСЫ см. ниже ) печатает числа от 0 до 9:
$ FOR (INT I=0;I<10;I++)
$ STRING S
$ CONVERT ( I, S )
$ PRINT ( S )
$ NEXT
======
WHILE:
======
$ WHILE ( условие )
$ ....действия......
$ WEND
Пример:
$ INT I=0
$ WHILE ( I<10 )
$ STRING S
$ CONVERT ( I, S )
$ PRINT ( S )
$ I++
$ WEND
===
DO:
===
$ DO
$ .....действия......
$ REDO ( условие )
DO от WHILE отличается тем, что DO выполнится хотя бы один раз, а WHILE не выполнится ни разу если условие не соблюдено.
Пример:
$ DO
$ STRING S
$ CONVERT ( I, S )
$ PRINT ( S )
$ I++
$ REDO ( I<10 )
======
SELECT
======
$ SELECT (переменная)
$ CASE значение:
$ ..действия..
$ BREAK
$ CASE значение:
$ ..действия..
$ BREAK
$ DEFAULT:
$ ..действия..
$ BREAK
$ ENDSELECT
Учтите, что SELECT нельзя использовать для строк.
ПРИМЕР:
$ INT I=1
$ SELECT (I)
$ CASE 0:
$ PRINT ( "zero" )
$ BREAK
$ CASE 1:
$ PRINT ( "one" )
$ BREAK
$ DEFAULT:
$ PRINT ( "unknown" )
$ BREAK
$ ENDSELECT
Полезные команды для циклов:
----------------------------
BREAK - выйти из цикла
CONTINUE - перескочить на начало цикла
==========================================
ТИПЫ ДАННЫХ
==========================================
BOOL - булев тип. значение 1 (TRUE) или 0 (FALSE)
INT - целое число от -30 до 30 тысяч
CINT - такое же целое число, но его нельзя будет изменить. удобно для констант
UINT - беззнаковое целое ( до 60 тысяч)
LONG - Большое ЧИСЛО. миллионы
ULONG - Большое Беззнаковое число. без знака минус то есть.
STRING - строка
CHAR - символ
FLOAT - число с плавающей точкой пониженной точности. для экономии памяти
DOUBLE - число с плавающей точкой повышенной точности
Модификатор CONST сделает число неизменным. Объявлять нужно сразу. Пример $ CONST LONG L = 5
Объявления переменных:
$ ТИП идентификатор_переменной
или
$ ТИП идентификатор_переменной = присваиваемое_значение
=================
СТРОКОВЫЕ ФУНКЦИИ
=================
Можно получать отдельные символы - STRING G="abcd" $ G[2] вернет 'c'.
Строки можно складывать с помощью +
Длина строки - G.LENGTH выдаст 4
Часть строки - G.MID(start,N) выдаст строку из N символов, начиная со start
Есть функция для замены текста внутри строки:
STRING text1 = "text to be replaced"
STRING text2 = "to be"
STRING text3 = REPLACE ( text1, text2, "was" )
В text3 будет "text was replaced"
Есть функция разбиения строки на несколько:
STRING gge = "testing split string"
STRING strl[256] //массив, в котором будут храниться строки
INT cncnt = SPLIT ( gge, ' ', strl ) //разделитель - пробел ' '
// cncnt содержит полученное количество элементов
FOR (int ie = 0; ie < cncnt; ie++) //печатаем все элементы
PRINT ( strl[ie] ) //функцию PRINT см. в макросах
NEXT
Получится:
testing
split
string
Для сравнения строк можно использовать такую функцию:
STRING a = "test"
STRING b = "test"
IF (a.COMPARE(b)==0) THEN //сравниваем a с b
//если они идентичны, этот код выполнится
ENDIF
========
МАССИВЫ
========
Массивы обозначаются [] скобками. Двойные - двойными [][]:
$ INT ARR[10]
$ ARR[0]=5
$ ARR[1]=6
или
$ INT ARR[]={1,2,7,4}
==========================================
ВЕКТОРЫ
==========================================
VECTOR vect1 (x,y) или VECTOR name() для вектора со значениями 0,0
vect1.x, vect1.y - доступ к значениям
vect1.SET(2.3d,-2.5d) - установка значений. d значит double
vect1.NORMALIZE() - нормализует вектор
vect1.GETANGLE() - возвращает угол в ГРАДУСАХ*
vect1.MOVE(ANGLE,STEP) - движет в сторону указанного угла на расстояние равное STEP
Векторы можно также перемножать, складывать, сравнивать как и обычные типы не только с векторами но и с дробными числами.
approxAngle(angle1, angle2, speed) - приближает angle1 к angle2 на величину speed.
==========================================
*Чтобы сконвертировать градусы в радианы и наоборот (пример):
==========================================
DOUBLE R = RADIANS(180)
DOUBLE D = DEGREES(R)
=========
ОПЕРАТОРЫ
=========
Используются операторы как в языке Си:
+ - / * += -= *= /= ++ --
Умножение и деление имеют высший приоритет, так что пользуйтесь скобками в неоднозначных ситуациях.
============
МАКРОСЫ
============
ПРИМЕЧАНИЕ: макрокоманды PRINT, CLS и LOCATE УЖЕ ВКЛЮЧЕНЫ В DUMMY и реализованы немного по-другому. Следующие макросы показаны лишь в качестве примера.
Макросы это мощные команды процессора. С их помощью можно создавать свои функции. Например, можно реализовать функцию PRINT, чтобы каждый раз не писать имя шрифта. Допустим мы загрузили шрифт в переменную FONT1. А в переменной COLOR у нас хранится цвет.
$ FONT FONT1 ( "test.ttf", 16 )
$ ULONG COLOR = 0xFF0000 // можно написать RED
В самом начале программы, без знака доллара пишем:
#define PRINT(X,Y,M) FONT1.DRAW((X),(Y),(M),COLOR)
Это и есть наша макрофункция.
Теперь, в программе можно написать:
$ PRINT ( 0, 0, "Hello!" ) // будет написано красным цветом
$ COLOR = CYAN
$ PRINT ( 0, 20, "Hello!" ) // будет написано голубым цветом
Полный код этой программы:
--------------------------
#include <DUMMY>
#define PRINT(X,Y,M) FONT1.DRAW((X),(Y),(M),COLOR)
$ FONT FONT1 ( "test.ttf", 16 )
$ ULONG COLOR = RED
$ PRINT ( 0, 0, "Hello!" )
$ COLOR = CYAN
$ PRINT ( 0, 20, "Hello!" )
$ UPDATE
$ WAIT (1000)
$ END
Давайте немного модифицируем нашу программу, чтобы переход на новые строчки осуществлялся автоматически. Для этого создадим переменные TEXTX и TEXTY, а также TEXTHEIGHT.
$ INT TEXTX = 0, TEXTY = 0, TEXTHEIGHT = 16, TEXTMARGIN = 4
В начале программы ( после #include <DUMMY> ) напишем обновленную макрофункцию:
#define PRINT(M) FONT1.DRAW(TEXTX,TEXTY,(M),COLOR);TEXTY+=TEXTHEIGHT+TEXTMARGIN
Добавим еще пару функций, которые были в старом добром BASIC:
#define LOCATE(X,Y) TEXTX=(X);TEXTY=(Y);
#define CLS(C) LOCATE(0,0);CLEAR((C))
-------------------------
Вот программа с примером:
-------------------------
#include <DUMMY>
#define PRINT(M) FONT1.DRAW(TEXTX,TEXTY,(M),COLOR);TEXTY+=TEXTHEIGHT+TEXTMARGIN
#define LOCATE(X,Y) TEXTX=(X);TEXTY=(Y);
#define CLS(C) LOCATE(0,0);CLEAR((C))
$ WINDOW
$ INT TEXTX = 0, TEXTY = 0, TEXTHEIGHT = 16, TEXTMARGIN = 4
$ FONT FONT1 ( "test.ttf", TEXTHEIGHT )
$ ULONG COLOR = RED
$ PRINT ( "Hello!" )
$ COLOR = CYAN
$ PRINT ( "Hello!" )
$ UPDATE
$ WAIT (1000)
$ CLS (BLACK)
$ PRINT ( "Cleared!" )
$ LOCATE ( 200, 200 )
$ PRINT ( "Moved!" )
$ UPDATE
$ WAIT (1000)
$ END
Как видите, возможности макросов очень обширны. Это последнее слово в программировании. Используйте макросы, чтобы облегчить свои задачи.
Еще раз напоминаю: PRINT, LOCATE и CLS уже реализованы в DUMMY.
==================================================
ПРИЛОЖЕНИЕ: КНОПКИ, ЦВЕТА и МАТЕМАТИЧЕСКИЕ ФУНКЦИИ
==================================================
Кнопки мыши: LB, MB, RB, WUP, WDOWN
Названия клавиш
===============
BACKSPACE ,TAB ,CLEAR ,ENTER ,PAUSE ,ESCAPE ,SPACE,EXCLAIM ,QUOTEDBL,HASH ,DOLLAR ,AMPERSAND ,QUOTE ,LEFTPAREN ,RIGHTPAREN ,ASTERISK ,PLUS ,COMMA,MINUS ,PERIOD ,SLASH ,_0 ,_1 ,_2 ,_3 ,_4 ,_5 ,_6 ,_7 ,_8 ,_9 ,COLON ,SEMICOLON,LESS,EQUALS ,GREATER ,QUESTION ,AT ,LEFTBRACKET ,BACKSLASH ,RIGHTBRACKET ,CARET ,UNDERSCORE ,BACKQUOTE ,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,DEL,KP0 ,KP1 ,KP2 ,KP3 ,KP4 ,KP5 ,KP6 ,KP7 ,KP8 ,KP9 ,KP_PERIOD ,KP_DIVIDE ,KP_MULTIPLY ,KP_MINUS ,KP_PLUS ,KP_ENTER ,KP_EQUALS ,UP ,DOWN ,RIGHT ,LEFT ,INSERT ,HOME ,END ,PAGEUP ,PAGEDOWN ,F1 ,F2 ,F3 ,F4 ,F5 ,F6 ,F7 ,F8 ,F9 ,F10 ,F11 ,F12 ,F13 ,F14 ,F15 ,NUMLOCK ,CAPSLOCK ,SCROLLOCK ,RSHIFT ,LSHIFT ,RCTRL ,LCTRL ,RALT ,LALT
Цвета и их значения в HTML формате.
Можно создавать свои цвета
----------------------------------
RED 0xFF0000
BLUE 0x0000FF
GREEN 0x00FF00
YELLOW 0xFFFF00
MAGENTA 0xFF00FF
CYAN 0x00FFFF
BLACK 0
WHITE 0xFFFFFF
GRAY 0x888888
DARKGRAY 0x444444
SILVER 0xAAAAAA
BROWN 0x752500
ORANGE 0xFF5000
DARKRED 0x750000
DARKGREEN 0x007500
DARKBLUE 0x000075
========
ЧИСЛО ПИ
========
PI - содержит число Пи.
Математические функции
----------------------
ABS Возвращает абсолютную величину числа
ACOS арккосинус
ACOSH гиперболический арккосинус
ASIN арксинус
ASINH гиперболический арксинус
ATAN арктангенс
ATAN2 арктангенс с двумя параметрами
ATANH гиперболический арктангенс
CBRT кубический корень
CEIL округление до ближайшего большего целого числа
COPYSIGN(X,Y) возвращает величину, абсолютное значение которой равно x, но знак которой соответствует знаку y
COS косинус
COSH гиперболический косинус
ERF функция ошибок
ERFC Дополнительная функция ошибок
EXP вычисление экспоненты
EXP2(X) значение числа 2, возведённого в степень x, pow(2,x)
EXPM1(X) значение функции pow(e,x)-1
FABS абсолютная величина (числа с плавающей точкой)
FDIM(X,Y) вычисление положительной разницы между x и y, fmax(x-y, 0)
FLOOR округление до ближайшего меньшего целого числа
FMA(X,Y,Z) значение функции (x * y) + z
FMAX(X,Y) наибольшее значение среди x и y
FMIN(X,Y) наименьшее значение среди x и y
FMOD вычисление остатка от деления нацело для чисел с плавающей точкой
FREXP разбивает число с плавающей точкой на мантиссу и показатель степени.
HYPOT(X,Y) гипотенуза, sqrt(x*x + y*y)
ILOGB экспонента числа с плавающей точкой, конвертированная в int
LDEXP умножение числа с плавающей точкой на целую степень двух
LGAMMA натуральный логарифм абсолютного значения гамма-функции
LLRINT округление до ближайшего целого (возвращает long long)
LLROUND округление до ближайшего целого в направлении от нуля (возвращает long long)
LOG натуральный логарифм
LOG10 логарифм по основанию 10
LOG1P(X) натуральный логарифм 1 + x
LOG2 логарифм по основанию 2
LOGB целочисленная часть логарифма x по основанию 2
LRINT округление до ближайшего целого (возвращает long)
LROUND округление до ближайшего целого в направлении от нуля (возвращает long)
NEXTAFTER(X,Y) следующий ближайшее представимое для x (по направлению к y)
NEXTTOWARD(X,Y) то же, что и nextafter, но y имеет тип long double
POW(X,Y) результат возведения x в степень y
REMAINDER(X,Y) вычисляет остаток от деления согласно стандарту IEC 60559
RINT округление до целого (возвращает int) с вызовом ошибки inexact, если результат отличается от аргумента.
ROUND округление до целого (возвращает double)
SCALBLN(X,N) x * FLT_RADIX^n (n is long)
SCALBN(X,N) x * FLT_RADIX^n (n is int)
SIN синус
SINH гиперболический синус
SQRT квадратный корень
TAN тангенс
TANH гиперболический тангенс
TGAMMA гамма-функция
TRUNC округление до ближайшего целого числа в направлении к нулю
==============
ПРИЛОЖЕНИЕ: СТЕК
==============
СТЕК и EXT1
Здравствуй, дорогой русский разработчик игр.
Ты наверняка уже написал много замечательных игр с помощью ДУММИ. Сегодня я хочу тебя познакомить со стеком. Что такое стек? Стек это замечательная вещь. Во многих учебниках о стеке говорят как о стопке тарелок. Ты кладешь тарелки в стопку и можешь снимать только сверху. Так и с переменными - кладешь несколько переменных, вызываешь подпрограмму, и достаешь в этой подпрограмме эти переменные (в обратном порядке). Есть две замечательные команды: POP и PUSH. PUSH помещает в стек, POP достаёт. Они работают с байтами (CHAR). Байты имеют значение от 0 до 255 либо символ ('a', ';' итп).
Пример использования команд PUSH и POP:
CHAR Z = 124
PUSH(10)
PUSH('t')
....
где-то в другом месте:
POP(CHAR T) // во вновь созданной переменной T будет символ t
POP(Z) - в Z будет 10
POP(CHAR N) // в N будет 124
Для целых чисел есть эквивалент - IPUSH, IPOP. Другие приставки: UI - беззнаковое целое, L - длинное целое, UL - беззнаковое длинное целое, F - плавающая точка, D - плавающая точка двойной точности. Эти приставки предваряют POP и PUSH: DPOP, UIPUSH.
Следует помнить о глубине стека. В DUMMY она составляет 65535 единиц для каждого типа стека (чего должно хватить с головой).
Итак, ты можешь использовать стек чтобы передавать подпрограммам значения:
#include <DUMMY>
$ GOTO(START) /* перескочим нашу подпрограмму */
$ SUB1:
$ BEGIN /* создадим локальную область, чтобы не сорить переменными */
$ IPOP(INT Y) /* обрати внимание: мы сначала достаём ИГРЕК, так как он был положен последним */
$ IPOP(INT X) /* а теперь ИКС */
$ LOCATE(X,Y)
$ PRINT("TEST!")
$ UPDATE
$ END /* конец локальной области */
$ RETURN
$ START:
$ IPUSH(160) /* кладем ИКС */
$ IPUSH(120) /* кладем ИГРЕК */
$ GOSUB(SUB1)
$ WAIT(1000)
$ END
================
ПРИЛОЖЕНИЕ: ОТЛАДКА
================
Отладка ДУММИ приложений
-----------------------------------
Чтобы отлаживать свою игру на ДУММИ, тебе нужно убрать на время команду -mwindows из make.bat. Дальше ты в любом месте программы пишешь команду:
$ print ( "текст\n" )
print пиши именно маленькими буквами. \n - значит, перенос строки.
Есть еще printLine, который сам переводит строчку. В качестве аргумента ты можешь указать какую нибудь переменную. Суть отладки в том, что ты "ловишь" момент выполнения какого-либо участка кода и можешь точно узнать выполняется он или нет или какое значение у определенной переменной в этот момент и т.д. Это и называется отладка.
Когда ты закончишь отладку, верни команду -mwindows на место. Свои отладочные сообщения можешь оставить - их никто не увидит.
Другой вариант:
Отладка с помощью PRINT прямо в игровом окне
--------------------------------------------
Суть в отслеживании переменных с помощью вывода их на графическое окно командами LOCATE/PRINT.
====================================================
ТРОЛЛИНГ ЛИ ЭТО? РЕАЛЬНО ЛИ НАПИСАТЬ ИГРУ НА DUMMY?
====================================================
Если в двух словах: нет, не троллинг. Да, README написан с некоторой долей юмора. И да, игру написать реально и DUMMY не создаёт никаких препятствий. Многие считают непреодолимым препятствием: отстуствие классов, функций, поощрение использования GOTO, отсутствие IDE.
Тем не менее, программисты на ассемблере на это не жалуются. Надо принять это как другой стиль программирования. Если вы сильно привыкли к ООП, то вам будет тяжело.
Напомню, что многие игровые хиты написаны именно на ассемблере - более низкоуровневом языке нежели DUMMY. В те времена существовал и BASIC и игры на нём писали, но они были медленные. DUMMY же по скорости сравним с С++, а по простоте - с BASIC.
=================
ЧТО ВНУТРИ DUMMY?
=================
Урезанный для экономии веса GNU Compiler Collection, библиотеки SDL (и то и другое для Windows) и главное: собственная надстройка над SDL и языком С++, а также специальным образом приготовленные пакетные файлы для безболезненной компиляции и запуска.
===================================
ЧТО НАСЧЕТ РАЗРАБОТКИ ИЗ ПОД LINUX?
===================================
Если вы хорошо в этом разбираетесь, то заглянёте в make.bat и соберете собственный DUMMY для Linux - вам понадобится gcc и dev версии SDL, возможно придется подправить пути к заголовочным файлам в файле DUMMY.
===============================================================
ЕСЛИ ВАМ ЧЕГО-ТО НЕ ХВАТАЕТ И ВЫ ХОТИТЕ ЧТО-ТО ИЗМЕНИТЬ В DUMMY
===============================================================
Учитывайте, что это уже будет другой язык и его исходный код будет невыполним у других DUMMY-программистов. Поэтому либо не делайте этого, либо распространяйте вместе с изменненным исходником DUMMY.
