Классификация языков программирования Критерии выбора среды и языка разработки программ.

Содержание:

ВВЕДЕНИЕ

На данный момент существует огромное количество языков. Есть и компилируемые и интерпретируемые языки, есть очень простые и очень сложные языки. Огромное многообразие в целом. И каждый их них создавался с определенной целью. Выбор языка программирования во время создания программы является очень важным моментом, от которого зависит почти все – скорость создания программы, скорость тестирования, возможность переноса на другие платформы, возможность быстрого внесения изменений, скорость выполнения конечного продукта, и так далее. При этом стоит отметить, что идеального языка не существует, все обладают своими положительными и отрицательными качествами, которые будут влиять на процесс разработки.

Классификация языков программирования. Критерии выбора среды и языка разработки программ.

1. Классификация языков программирования.

На заре компьютерной эры машинный код был единственным средством общения человека с компьютером. Огромным достижением создателей языков программирования было то, что они сумели заставить сам компьютер работать переводчиком с этих языков на машинный код.

Существующие языки программирования можно разделить на две группы: процедурные и непроцедурные (Рис. 1).

Процедурные (или алгоритмические) программы представляют из себя систему предписаний для решения конкретной задачи. Роль компьютера сводится к механическому выполнению этих предписаний.

Процедурные языки разделяют на языки низкого и высокого уровня.

Разные типы процессоров имеют разные наборы команд. Если язык программирования ориентирован на конкретный тип процессора и учитывает его особенности, то он называется языком программирования низкого уровня.

Имеется в виду, что операторы языка близки к машинному коду и ориентированы на конкретные команды процессора.

Рис. 1. Общая классификация языков программирования.

Языки низкого уровня (машинно-ориентированные) позволяют создавать программы из машинных кодов, обычно в шестнадцатеричной форме. С ними трудно работать, но созданные с их помощью высококвалифицированным программистом программы занимают меньше места в памяти и работают быстрее. С помощью этих языков удобнее разрабатывать системные программы, драйверы (программы для управления устройствами компьютера), некоторые другие виды программ.

Языком низкого уровня (машинно-ориентированным) является Ассемблер, который просто представляет каждую команду машинного кода, но не в виде чисел, а с помощью условных символьных обозначений, называемых - мнемониками.

С помощью языков низкого уровня создаются очень эффективные и компактные программы, так как разработчик получает доступ ко всем возможностям процессора.

Языки программирования высокого уровня значительно ближе и понятнее человеку, нежели компьютеру. Особенности конкретных компьютерных архитектур в них не учитываются, поэтому создаваемые программы на уровне исходных текстов легко переносимы на другие платформы, для которых создан транслятор этого языка. Разрабатывать программы на языках высокого уровня с помощью понятных и мощных команд значительно проще, а ошибок при создании программ допускается гораздо меньше.

Основное достоинство алгоритмических языков высокого уровня - возможность описания программ решения задач в форме, максимально удобной для восприятия человеком. Но так как каждое семейство ЭВМ имеет свой собственный, специфический внутренний (машинный) язык и может выполнять лишь те команды, которые записаны на этом языке, то для перевода исходных программ на машинный язык используются специальные программы-трансляторы.

Работа всех трансляторов строится по одному из двух принципов: интерпретация или компиляция.

Интерпретация подразумевает пооператорную трансляцию и последующее выполнение оттранслированного оператора исходной программы. В связи с этим можно отметить два недостатка метода интерпретации: во-первых, интерпретирующая программа должна находиться в памяти ЭВМ в течение всего процесса выполнения исходной программы, т. е. занимать определенный объем памяти; во-вторых, процесс трансляции одного и того же оператора повторяется столько раз, сколько раз должна исполняться эта команда в программе, что резко снижает производительность работы программы.

Несмотря на указанные недостатки, трансляторы-интерпретаторы получили достаточное распространение, так как они удобны при разработке и отладке исходных программ.

При компиляции процессы трансляции и выполнения разделены во времени: сначала исходная программа полностью переводится на машинный язык (после чего наличие транслятора в оперативной памяти становится ненужным), а затем оттранслированная программа может многократно исполняться. Следовательно, для одной и той же программы трансляция методом компиляции обеспечивает более высокую производительность вычислительной системы при сокращении требуемой оперативной памяти.

Большая сложность в разработке компилятора по сравнению с интерпретатором с того же самого языка объясняется тем, что компиляция программы включает два действия: анализ, т. е. определение правильности записи исходной программы в соответствии с правилами построения языковых конструкций входного языка, и синтез – генерирование эквивалентной программы в машинных кодах. Трансляция методом компиляции требует неоднократного «просмотра» транслируемой программы, т. е. трансляторы-компиляторы являются многопроходными: при первом проходе они проверяют корректность синтаксиса языковых конструкций отдельных операторов независимо друг от друга, при последующем проходе – корректность синтаксических взаимосвязей между операторами и т. д.

Полученная в результате трансляции методом компиляции программа называется объектным модулем, который представляет собой эквивалентную программу в машинных кодах, но не «привязанную» к конкретным адресам оперативной памяти. Поэтому перед исполнением объектный модуль должен быть обработан специальной программой операционной системы (редактором связей – Link) и преобразован в загрузочный модуль.

Наряду с рассмотренными выше трансляторами-интерпретаторами и трансляторами-компиляторами на практике используются также трансляторы интерпретаторы-компиляторы, которые объединяют в себе достоинства обоих принципов трансляции: на этапе разработки и отладки программ транслятор работает в режиме интерпретатора, а после завершения процесса отладки исходная программа повторно транслируется в объектный модуль (т. е. уже методом компиляции). Это позволяет значительно упростить и ускорить процесс составления и отладки программ, а за счет последующего получения объектного модуля обеспечить более эффективное исполнение программы.

Классическое процедурное программирование требует от программиста детального описания того, как решать задачу, т. е. формулировки алгоритма и его специальной записи. При этом ожидаемые свойства результата обычно не указываются. Основные понятия языков этих групп – оператор и данные.

При процедурном подходе операторы объединяются в группы – процедуры. Структурное программирование в целом не выходит за рамки этого направления, оно лишь дополнительно фиксирует некоторые полезные приемы технологии программирования.

Принципиально иное направление в программировании связано с методологиями (иногда говорят «парадигмами») непроцедурного программирования. К ним можно отнести объектно-ориентированное и декларативное программирование. Объектно-ориентированный язык создает окружение в виде множества независимых объектов. Каждый объект ведет себя подобно отдельному компьютеру, их можно использовать для решения задач как «черные ящики», не вникая во внутренние механизмы их функционирования. Из языков объектного программирования, популярных среди профессионалов, следует назвать прежде всего Си++, для более широкого круга программистов предпочтительны среды типа Delphi и Visual Basic.

При использовании декларативного языка программист указывает исходные информационные структуры, взаимосвязи между ними и то, какими свойствами должен обладать результат. При этом процедуру его получения («алгоритм») программист не строит (по крайней мере, в идеале). В этих языках отсутствует понятие «оператор» («команда»). Декларативные языки можно подразделить на два семейства – логические (типичный представитель – Prolog) и функциональные (Lisp).

Охарактеризуем наиболее известные языки программирования:

FORmula TRANslating system (FORTRAN) – система трансляции формул. Cтарейший и по сей день активно используемый в решении задач математической ориентации язык. Является классическим языком для программирования на ЭВМ математических и инженерных задач

Beginner's All-purpose Symbolic Instruction Code (BASIC) – универсальный символический код инструкций для начинающих); несмотря на многие недостатки и изобилие плохо совместимых версий – самый популярный по числу пользователей. Широко употребляется при написании простых программ.

ALGOrithmic Language (ALGOL) – алгоритмический язык); сыграл большую роль в теории, но для практического программирования сейчас почти не используется.

Programming Language 1 (PL/1) – язык программирования первый); многоцелевой язык; сейчас почти не используется.

Pascal – назван в честь ученого Блеза Паскаля. Чрезвычайно популярен как при изучении программирования, так и среди профессионалов. Создан в начале 70-х годов швейцарским ученым Никлаусом Виртом. Язык Паскаль первоначально разрабатывался как учебный, и, действительно, сейчас он является одним из основных языков обучения программированию в школах и вузах. Однако качества его в совокупности оказались столь высоки, что им охотно пользуются и профессиональные программисты. Не менее впечатляющей, в том числе и финансовой, удачи добился Филип Кан, француз, разработавший систему Turbo-Pascal. Суть его идеи состояла в объединении последовательных этапов обработки программы – компиляции, редактирования связей, отладки и диагностики ошибок – в едином интерфейсе. Версии Turbo-Pascal заполонили практически все образовательные учреждения, программистские центры и частные фирмы. На базе языка Паскаль созданы несколько более мощных языков (Modula, Ada, Delphi).

COmmon Business Oriented Language (COBOL) – язык, ориентированный на общий бизнес); в значительной мере вышел из употребления. Был задуман как основной язык для массовой обработки данных в сферах управления и бизнеса.

ADA - является языком, победившим (май 1979 г.) в конкурсе по разработке универсального языка, проводимым Пентагоном с 1975 году. Разработчики – группа ученых во главе с Жаном Ихбиа. Победивший язык окрестили ADA, в честь Огасты Ады Лавлейс. Язык ADA – прямой наследник языка Pascal

С – широко используется при создании системного программного обеспечения. Наложил большой отпечаток на современное программирование (первая версия – 1972 г.), является очень популярным в среде разработчиков систем программного обеспечения (включая операционные системы). C сочетает в себе черты как языка высокого уровня, так и машинно-ориентированного языка, допуская программиста ко всем машинным ресурсам, чего не обеспечивают такие языки, как BASIC и Pascal.

С++ – объектно-ориентированное расширение языка C, созданное Бьярном Страуструпом в 1980 году. Множество новых мощных возможностей, позволивших резко повысить производительность программистов, наложилось на унаследованную от языка C определенную низкоуровневость.

Delphi – язык объектно-ориентированного «визуального» программирования; в данный момент чрезвычайно популярен. Созданный на базе языка Pascal специалистами фирмы Borland язык Delphi, обладая мощностью и гибкостью языков C и C++, превосходит их по удобству и простоте интерфейса при разработке приложений, обеспечивающих взаимодействие с базами данных и поддержку различного рода работ в рамках корпоративных сетей и сети Интернет.

Java – платформенно-независимый язык объектно-ориентированного программирования, чрезвычайно эффективен для создания интерактивных веб-страниц. Этот язык был создан компанией Sun в начале 90-х годов на основе C++. Он призван упростить разработку приложений на основе C++ путем исключения из него всех низкоуровневых возможностей.

Lisp – функциональный язык программирования. Ориентирован на структуру данных в форме списка и позволяет организовать эффективную обработку больших объемов текстовой информации.

PROgramming in LOGic (PROLOG) – Главное назначение языка – разработка интеллектуальных программ и систем. PROLOG– это язык программирования, созданный специально для работы с базами знаний, основанными на фактах и правилах (одного из элементов систем искусственного интеллекта). В языке реализован механизм возврата для выполнения обратной цепочки рассуждений, при котором предполагается, что некоторые выводы или заключения истинны, а затем эти предположения проверяются в базе знаний, содержащей факты и правила логического вывода. Если предположение не подтверждается, выполняется возврат и выдвигается новое предположение. В основу языка положена математическая модель теории исчисления предикатов.

Выбор языка программирования зависит от многих факторов: назначения, удобства написания исходных программ, эффективности получаемых объектных программ и т. п. Разнотипность решаемых компьютером задач и определяет многообразие языков программирования.

1.1 Критерии выбора языка программирования.

К критериям выбора языка программирования я считаю стоит отнести такие как:

Скорость работы конечного продукта. Требовательным к скорости выполнения могут быть программы с большим объемом математических вычислений, например моделирование физических систем, расчеты экономических данных, вывод трехмерной графики и так далее. Для данных целей хорошо подходят компилируемые языки: Assembler, C/C++, Fortran и т.д. после компиляции программа не требует ничего лишнего и содержит в себе машинные команды, которые выполняются без дополнительных задержек. Схема работы таких программ: Программа исполняется сразу, не требуя дополнительных библиотек; программа помимо своего кода содержит вызовы библиотек с машинным кодом (системные и входящие в проект), кроме исполнения собственных команд, программа вызывает функции из библиотек; так же программа может работать через прослойку из драйверов, которые в свою очередь написаны на языках низкого уровня и работают быстро.

Объем занимаемой оперативной памяти. Данное требование чаше всего актуально, когда программа разрабатывается для встраиваемых систем, мобильных платформ, микроконтроллеров и т.д. В данном случае чем меньше памяти использует программа на данном языке – тем лучше. Сюда можно отнести языки: Assembler, C/C++, Objective-C и т.д. список подобен скорости работы, обусловлено это тем что чем меньше функциональных блоков в схеме исполнения, тем меньше памяти компьютера использует программа.

Скорость разработки программы. Данное требование актуально для разработки программ, которые нужно сделать в короткий срок. Сюда подходят высокоуровневые языки. Java, Flash и т.д. На данных языках время разработки существенно сокращается за счет обилия сторонних библиотек, максимально понятного синтаксиса, и подобного. Скорость выполнения программ, написанных на высокоуровневых языках, существенно падает, так как программа находится в виде байт-кода. И для его исполнения нужен анализатор, который должен транслировать байт-код в машинный «на лету», при этом потратив много времени на точный анализ инструкций.

Ориентированность на пользователя. Тут в свою очередь необходимо понимать с кем программа должна работать в первую очередь, компьютер или человек. Так как для работы с человеком, программа должна обладать хорошо продуманной графической частью, которая отвечает требованиям дизайна и юзабилити. На разработку графической части уходит достаточно много времени, так как разработка графического интерфейса отличается немалой сложностью. Сложность в том что вывод графики – это приличное количество математических расчетов, а отсюда следует что требуется и хорошая скорость выполнения программы, а из-за сложности разработки присутствует необходимость в высокоуровневом языке. Для данных задач хорошо подходит C++/C# одновременно и высокоуровневые, и скоростью выполнения на них. Если программа ориентирована в первую очередь на работу с компьютером с минимальным воздействием пользователя, тогда выбор должен ложится в сторону быстрых языков (Assembler, C)

Кроссплатформенность – возможность работы программы на различных платформах, в различных ОС с минимальными изменениями. В этой сфере можно выделить такие языки как: Java, C++, C#, Flash с различными библиотеками.

Java создавалась с тем условием что программы на данном языке должны работать на любой платформе, где есть JVM (Java Virtual Machine). Программы на Java вообще не требуют никаких изменений. После компиляции получается «.jar» файл, который будет работать и на Windows, и на Mac OS, и на Linux, а также в любом другом месте, где присутствует JVM. С C++ несколько иначе, на чистом C++ написать кроссплатформенную программу довольно трудно, у кода возникает обширная избыточность и достоинство в скорости выполнения теряется. Обычно используют кроссплатформенные библиотеки, такие как «Qt», которые позволяют достичь принципа «один код на все платформы», однако программу для каждой платформы придется компилировать отдельно и разными компиляторами. Сюда также можно включить и интерпретируемые языки, скриптовые языки – для их работы нужно наличие интерпретатора языка в системе. Данные языки довольно удобны в плане разработки, но медлительны. Так же достаточно большое потребление памяти компьютера.

1.2 Скорость внесения изменений и скорость тестирования

Если проект быстро развивается, в него постоянно вносят изменения. Тогда выбор должен падать на высокоуровневые языки, где любой функциональный блок можно переписать. Так как заниматься дебажить, например C++ намного проще, чем Assembler. Но тут очень много тонкостей, которые по большей части находятся в языке, сколь в разработчике с его стилем программирования и компиляторах, которые он использует. Так же и язык вносит свою долю, так или иначе упрощая или усложняя работу программиста.

1.3 Критерии выбора среды

Для меня что-то конкретное отнести к критериям выбора среды разработки довольно сложно, так как для каждого конкретного языка программирования по большей части существует своя среда разработки, она же IDE, и для каждого разработчика эта своя которая ему более удобна. Конечно, никто не запрещает пользоваться обычным блокнотом, но в то же время уже для каждого языка программирования есть своя IDE которая заточена на работу с ним, что упрощает и ускоряет разработку на выбранном языке программирования. На пример для работы с языками для платформы .NET Framework, по моему счету отлично подходит Visual Studio. В ней есть все что необходимо для работы с данной платформой, и IntelliSense – технология автодополнения Microsoft которая дописывает название функции или переменной при вводе начальных букв, что в разы ускоряет разработку и программы. Подсветка синтаксиса, что упрощает написание и чтение программного кода. Возможность отладки написанной программы, конечно, возможность проверить программу это отличный способ, найти и устранить ошибки, которые были допущены при разработке.

Возможность IDE настраивать под себя, считаю отличным дополнением к IDE, так как это позволяет более комфортно чувствовать себя при работе с данной IDE, ну и в некотором случае ускорении разработки программы, так в некоторых IDE можно добавлять свои шаблоны различных классов и функций, которые можно вставлять в несколько нажатий, а не писать их или искать и копировать уже разработанный функционал.

На данный момент я пользуюсь Visual Studio Code, это редактор который можно настроить по функционалу ни чуть не уступающий Visual Studio, с помощью всевозможных расширений которые разрабатываются, как Microsoft, так и сообществом, которое пользуется данным редактором, так же достоинством данного редактором является возможность использования данного редактора на различных платформах: Windows, Linux, MacOS

Существенным плюсом для данного редактора является сохранение внесенных изменений, что позволяет не беспокоиться о том что какой то участок кода мог был потерян, в каких то критических ситуациях, например как непредвиденное завершение работы операционной системы, полностью позволяет не беспокоится за потраченные часы. А возможность полной кастомизации данного редактора, позволяет подстроить его под себя и свои нужды.

Исходя из этих под тем, можно сказать следующее, на данный момент очень большой выбор языков программирования, которые подходят под те или иные задачи и у каждого языка есть свои тонкости, которые следует учитывать, например что большие программы могут состоять из подпрограмм которые написаны на разных языках в зависимости от нужд данной подпрограммы. К примеру, программы где необходим высокая скорость работы программы, пишут в основном на низкоуровневых языка, а графическая составляющая на высокоуровневых и более медленных. По моему мнению языки C и C++ это очень универсальные языки, огромным количеством библиотек с отличной скоростью работы и своими плюсами. Но у этих языков есть конечно и свой недостаток, это то, что за свою универсальность они платятся тем, что они сложны в освоении и нюансы.

На счет Java, не смотря на его универсальность и простоту освоения, у данного языка есть свой недостаток, который порой перекрывает, простоту разработки под различные платформы, это то что он платится своей скоростью работы, от сюда следует его ограничения, например большие программы на нем можно написать, но работать они будут довольно медленно, а так же высокое требование к аппаратному обеспечению.

Скриптовые и интерпретируемые языки, хорошо подходят для разработки автоматизации различных действий, а так же при встраивании в другие языки.

Про Assembler я бы что-то и рассказал, но я еще не проявил желания в его изучении, так как считаю его для меня одним из самых сложных в освоении языков. Но в свою очередь это один из самых производительных языков, если все правильно написать и использовать.

Глава 2. Практическая часть

В данную главу хочу внести несколько примеров из разных языков.

Змейка написанная на C:

#include <stdio.h>

#include <conio.h>
#include <Windows.h>
#include <stdlib.h>
#include <time.h>

#define SIZEX 65
#define SIZEY 20
#define MAXSIZE_SNAKE 100

int foodPosX = -1, foodPosY = -1, foodIsLive;
int score = 0, life = 1;

void textAttr(int color) {
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), color);
}

void checkBody(int curX, int curY, int snake[2][MAXSIZE_SNAKE]) {
int i;
for (i = 1; i < MAXSIZE_SNAKE; ++i) {
if (snake[0][i] == curX && snake[1][i] == curY) {
life = 0;
break;
}
}
}

void gotoxy(int x, int y) {
COORD c = { x, y };
SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), c);
}

void updateScore(int x, int y) { // x + 2 y
gotoxy(x + 2, y);
printf("Score: %d", score);
gotoxy(x + 2, y + 1);
printf("Food: ");
textAttr(0x0C);
printf(" %c", 3);
textAttr(0x07);
}

void printCreator(int x, int y) { // x + 2 y
gotoxy(x + 2, y);
printf("Created");
gotoxy(x + 2, y + 1);
printf("By RedZvER");
}

void printFood(int maxX, int maxY) {
int posX, posY;

posX = rand() % maxX + 1;
posY = rand() % maxY + 1;

if (posX > 0 && posX < maxX - 1 && posY > 0 && posY < maxY - 1) {
gotoxy(posX, posY);
textAttr(0x0C);
printf("%c", 3);
textAttr(0x07);

if (foodPosX != -1 && foodPosY != -1) {
gotoxy(foodPosX, foodPosY);
printf(" ");
}

foodPosX = posX;
foodPosY = posY;
foodIsLive = 1;
}
}

void printBorder(int sizeX, int sizeY) {
int i, j;

for (i = 0; i < sizeY; ++i) {
for (j = 0; j < sizeX; ++j)
printf("%c", (i == 0 || j == 0 || j == sizeX - 1 || i == sizeY - 1) ? (textAttr(0x0A), '#') : ' ');
textAttr(0x07);
printf("\n");
}
}

int main() {
srand((unsigned)time(NULL)); rand();

int key, dx = 1, dy = 0;
int l, r, u, d;
int i;

foodIsLive = l = u = d = 0;
r = 1;

printBorder(SIZEX, SIZEY);
updateScore(SIZEX, 0);
printCreator(SIZEX, 5);
int tSize = 5;
int m[2][MAXSIZE_SNAKE]; // [x,y] [ MAXSIZE_SNAKE ]

m[0][0] = 40; m[1][0] = 12;
m[0][1] = 39; m[1][1] = 12;
m[0][2] = 38; m[1][2] = 12;
m[0][3] = 37; m[1][3] = 12;
m[0][4] = 36; m[1][4] = 12;

while (1) {
gotoxy(m[0][0], m[1][0]);
textAttr(0x0e);
putchar(1);

//print snake body
for (i = 1; i < tSize; ++i) {
gotoxy(m[0][i], m[1][i]);
putchar('o');
}
textAttr(0x07);

if (_kbhit() != 0) {
key = _getch();
if (key == 27) break;
if (key == 32) { gotoxy(0, SIZEY); system("pause"); }
if (key == 0) key = _getch();
if (key == 75 && !r) { dy = 0; dx = -1; u = d = r = 0; l = 1; }
if (key == 77 && !l) { dy = 0; dx = 1; u = d = l = 0; r = 1; }
if (key == 72 && !u) { dy = -1; dx = 0; l = r = u = 0; d = 1; }
if (key == 80 && !d) { dy = 1; dx = 0; l = r = d = 0; u = 1; }
}

if (m[0][0] == foodPosX && m[1][0] == foodPosY) {
tSize++;
score += 5;
foodIsLive = 0;
updateScore(SIZEX, 0);
}

gotoxy(m[0][tSize - 1], m[1][tSize - 1]);
putchar(' ');

for (i = tSize - 1; i > 0; i--)
{
m[0][i] = m[0][i - 1];
m[1][i] = m[1][i - 1];
}

m[0][0] += dx; m[1][0] += dy;
checkBody(m[0][0], m[1][0], m);

if (m[0][0] <= 0 || m[0][0] >= SIZEX - 1 || m[1][0] <= 0 || m[1][0] >= SIZEY - 1 || life == 0) {
break;
}

if (foodIsLive == 0) {
printFood(SIZEX - 1, SIZEY - 1);
}

Sleep(90);
}
gotoxy(0, SIZEY + 1);
printf("Game Over\nScore: %d\n", score);
system("pause");
return 0;
}

Автоатака на C#

using UnityEngine;

using System;

using System.Collections;

using System.Collections.Generic;

public class AutoAttack : MonoBehaviour {

public float attackRadius;

[Range(0,360)]

public float attackAngle;

public float attackSpeed;

public LayerMask obstacleMask;

public GameObject _Fire, _Water, _Earth, _Wind;

public GameObject orb_Spot;

public float fire_speed, water_speed, earth_speed;

public float degreePerSecond = 40f;

[HideInInspector]

public List<Transform> visibleTargets = new List<Transform>();

[HideInInspector]

public int edgeResolveIterations;

[HideInInspector]

public float edgeDstThreshold;

public float meshResolution = 1f;

public MeshFilter viewMeshFilter;

Mesh viewMesh;

public float maskCutawayDst = 0.1f;

public GameObject attackTarget;

private Vector3 targetPos;

public MagesAttackType.MageType type;

private Vector3 doAttackAngle;

public void SetAutoAttackType(string _type)

{

type = (MagesAttackType.MageType)Enum.Parse(typeof(MagesAttackType.MageType), _type, true);

Debug.Log(type.ToString());

}

void Start () {

viewMesh = new Mesh ();

viewMesh.name = "View Mesh";

viewMeshFilter.mesh = viewMesh;

StartCoroutine("FindTargetWithDelay", 0.2f);

StartCoroutine("AutoAttackEnum");

}

IEnumerator FindTargetWithDelay(float delay)

{

while (true)

{

yield return new WaitForSeconds(delay);

FindVisibleTargets();

}

}

/*

void LateUpdate () {

DrawFieldOfAttack();

}*/

void FindVisibleTargets()

{

visibleTargets.Clear();

Collider[] targetsInAttackRadius = Physics.OverlapSphere(transform.position, attackRadius);

float closest_dst = attackRadius;

GameObject closest_go = null;

int count_ia = 0;

for (int i = 0; i < targetsInAttackRadius.Length; i++)

{

GameObject target = targetsInAttackRadius[i].gameObject;

if (target.tag != "Enemy") continue;

Transform t_target = target.transform;

Vector3 dirToTarget = (t_target.position - transform.position).normalized;

if (Vector3.Angle(transform.forward, dirToTarget) < attackAngle / 2)

{

float dstToTarget = Vector3.Distance(transform.position, t_target.position);

if (!Physics.Raycast(transform.position, dirToTarget, dstToTarget, obstacleMask))

{

count_ia++;

visibleTargets.Add(t_target);

if (dstToTarget < closest_dst)

{

doAttackAngle = dirToTarget;

closest_dst = dstToTarget;

closest_go = target;

}

}

}

}

if (count_ia == 0)

{

attackTarget = null;

}

else

{

attackTarget = closest_go;

}

}

public GameObject getGameObjType(MagesAttackType.MageType type)

{

switch (type)

{

case MagesAttackType.MageType.None:

return null;

case MagesAttackType.MageType.Fire:

return _Fire;

case MagesAttackType.MageType.Water:

return _Water;

case MagesAttackType.MageType.Earth:

return _Earth;

case MagesAttackType.MageType.Wind:

return _Wind;

default:

return null;

}

}

public float getSpeedObjType(MagesAttackType.MageType type)

{

switch (type)

{

case MagesAttackType.MageType.None:

return 0f;

case MagesAttackType.MageType.Fire:

return fire_speed;

case MagesAttackType.MageType.Water:

return water_speed;

case MagesAttackType.MageType.Earth:

return earth_speed;

case MagesAttackType.MageType.Wind:

return 0f;

default:

return 0f;

}

}

IEnumerator AutoAttackEnum()

{

while (true)

{

yield return new WaitForSeconds(attackSpeed);

if (attackTarget != null)

{

if (getGameObjType(type) != null)

{

// start rotate

Quaternion start_rot = transform.rotation;

Vector3 dir = Vector3.ProjectOnPlane(attackTarget.transform.position - transform.position, Vector3.up);

Quaternion target_rot = Quaternion.LookRotation(dir);

float elapsed_time = 0f;

float rot_time = Quaternion.Angle(target_rot, transform.rotation) / degreePerSecond;

Debug.Log(rot_time);

while (Quaternion.Angle(target_rot, transform.rotation) > 2 && elapsed_time < rot_time)

{

elapsed_time += Time.deltaTime;

transform.rotation = Quaternion.Slerp(start_rot, target_rot, (elapsed_time / rot_time));

yield return new WaitForEndOfFrame();

}

// end rotate

if (getGameObjType(type) != _Wind)

{

GameObject attack = (GameObject)Instantiate(getGameObjType(type), orb_Spot.transform.position, this.transform.rotation);

attack.GetComponent<Rigidbody>().AddForce(doAttackAngle * getSpeedObjType(type), ForceMode.Impulse);

}

else

{

GameObject wind = (GameObject)Instantiate(getGameObjType(type));

wind.transform.position = orb_Spot.transform.position;

Vector3 v = attackTarget.transform.position;

wind.transform.LookAt(v);

wind.transform.Rotate(new Vector3(90, wind.transform.rotation.y, wind.transform.rotation.z));

}

}

}

}

}

void DrawFieldOfAttack()

{

int stepCount = Mathf.RoundToInt(attackAngle * meshResolution);

float stepAngleSize = attackAngle / stepCount;

List<Vector3> viewPoints = new List<Vector3>();

ViewCastInfo oldViewCast = new ViewCastInfo();

for (int i = 0; i <= stepCount; i++)

{

float angle = transform.eulerAngles.y - attackAngle / 2 + stepAngleSize * i;

ViewCastInfo newViewCast = ViewCast(angle);

if (i > 0)

{

bool edgeDstThresholdExceeded = Mathf.Abs(oldViewCast.dst - newViewCast.dst) > edgeDstThreshold;

if (oldViewCast.hit != newViewCast.hit || (oldViewCast.hit && newViewCast.hit && edgeDstThresholdExceeded))

{

EdgeInfo edge = FindEdge(oldViewCast, newViewCast);

if (edge.pointA != Vector3.zero)

{

viewPoints.Add(edge.pointA);

}

if (edge.pointB != Vector3.zero)

{

viewPoints.Add(edge.pointB);

}

}

}

viewPoints.Add(newViewCast.point);

oldViewCast = newViewCast;

}

int vertexCount = viewPoints.Count + 1;

Vector3[] vertices = new Vector3[vertexCount];

int[] triangles = new int[(vertexCount - 2) * 3];

vertices[0] = Vector3.zero;

for (int i = 0; i < vertexCount - 1; i++)

{

vertices[i + 1] = transform.InverseTransformPoint(viewPoints[i]) + Vector3.forward * maskCutawayDst;

if (i < vertexCount - 2)

{

triangles[i * 3] = 0;

triangles[i * 3 + 1] = i + 1;

triangles[i * 3 + 2] = i + 2;

}

}

viewMesh.Clear();

viewMesh.vertices = vertices;

viewMesh.triangles = triangles;

viewMesh.RecalculateNormals();

}

EdgeInfo FindEdge(ViewCastInfo minViewCast, ViewCastInfo maxViewCast)

{

float minAngle = minViewCast.angle;

float maxAngle = maxViewCast.angle;

Vector3 minPoint = Vector3.zero;

Vector3 maxPoint = Vector3.zero;

for (int i = 0; i < edgeResolveIterations; i++)

{

float angle = (minAngle + maxAngle) / 2;

ViewCastInfo newViewCast = ViewCast(angle);

bool edgeDstThresholdExceeded = Mathf.Abs(minViewCast.dst - newViewCast.dst) > edgeDstThreshold;

if (newViewCast.hit == minViewCast.hit && !edgeDstThresholdExceeded)

{

minAngle = angle;

minPoint = newViewCast.point;

}

else

{

maxAngle = angle;

maxPoint = newViewCast.point;

}

}

return new EdgeInfo(minPoint, maxPoint);

}

ViewCastInfo ViewCast(float globalAngle)

{

Vector3 dir = DirFromAngle(globalAngle, true);

RaycastHit hit;

if (Physics.Raycast(transform.position, dir, out hit, attackRadius, obstacleMask))

{

return new ViewCastInfo(true, hit.point, hit.distance, globalAngle);

}

else

{

return new ViewCastInfo(false, transform.position + dir * attackRadius, attackRadius, globalAngle);

}

}

public Vector3 DirFromAngle(float angleInDegrees, bool angleIsGlobal)

{

if (!angleIsGlobal)

{

angleInDegrees += transform.eulerAngles.y;

}

return new Vector3(Mathf.Sin(angleInDegrees * Mathf.Deg2Rad), 0, Mathf.Cos(angleInDegrees * Mathf.Deg2Rad));

}

public struct ViewCastInfo

{

public bool hit;

public Vector3 point;

public float dst;

public float angle;

public ViewCastInfo(bool _hit, Vector3 _point, float _dst, float _angle)

{

hit = _hit;

point = _point;

dst = _dst;

angle = _angle;

}

}

public struct EdgeInfo

{

public Vector3 pointA;

public Vector3 pointB;

public EdgeInfo(Vector3 _pointA, Vector3 _pointB)

{

pointA = _pointA;

pointB = _pointB;

}

}

}

public class MagesAttackType

{

public enum MageType

{

None,

Fire,

Water,

Earth,

Wind

}

public MageType attackType;

public GameObject attackPref;

}

Часть плагина авторизации на Java

package ru.redzver.joinallow;

import java.io.File;

import java.util.logging.Logger;

import org.bukkit.ChatColor;

import org.bukkit.configuration.file.YamlConfiguration;

import org.bukkit.plugin.java.JavaPlugin;

public class JoinAllow extends JavaPlugin {

public static JoinAllow Instance;

public static String PluginNameWColor = ChatColor.YELLOW + "[" + ChatColor.GREEN + "JoinAllow" + ChatColor.YELLOW + "]" + ChatColor.GRAY;

public static String PluginName = "[JoinAllow]";

public static String JoinMessage = "{player} joined the game";

public static String TimeMessage = "subscription ending in {endtime}";

public static String KickMessage = "{player}, subscription expires";

public static String SiteUrl = "http://minecraft.local/";

public static String SiteOutLocal = "en";

private File configFile;

private YamlConfiguration config;

private static Logger log = Logger.getLogger("Minecraft");

@Override

public void onEnable() {

Instance = this;

RegisterListeners();

InitConfig();

LoadConfigData();

Log("Enabled");

}

@Override

public void onDisable() {

Log("Disabled");

}

public static void Log(String msg) {

log.info(PluginName + " " + msg);

}

private void RegisterListeners() {

getServer().getPluginManager().registerEvents(new PlayerLoginListener(), this);

}

private void InitConfig() {

configFile = new File(getDataFolder(), "config.yml");

if(!configFile.exists()) {

saveResource("config.yml", true);

}

config = new YamlConfiguration();

try {

config.load(configFile);

} catch (Exception e) {

e.printStackTrace();

}

}

private void LoadConfigData() {

JoinMessage = Utils.ReplaceColor(config.getString("JoinMessage"));

KickMessage = Utils.ReplaceColor(config.getString("KickMessage"));

TimeMessage = Utils.ReplaceColor(config.getString("TimeMessage"));

SiteOutLocal = config.getString("SiteOutLocal");

}

}

Список используемой литературы

1. Байдачный С.С. .NET Framework. Секреты создания Windows-приложений. – М.: СОЛОН-Пресс, 2004. – 496 с.
2. Гербердт Шилдт. C#: учебный курс. – СПб.: Питер; К.: Издательская группа BHV, 2003. – 512 c.: ил. СПб.: Питер, 2002. – 464 с.
3. Медведев В.И. Особенности объектно-ориентированного программирования на C++/CLI, C# и Java. – Казань: РИЦ «Школа», 2008. – 360 c.– (Серия «Современная прикладная математика и информатика»).
4. Медведев В.И. Программирование на С++, С++.NET/C# и .NET компоненты. – Казань: Мастер Лайн, 2006. – 296 c.
5. Медведев В.И. Программирование на C++,C++.NETиC# (Серия “Современная прикладная математика и информатика”). – Казань: Мастер Лайн, 2005. – 270c.
6. Петцольд Ч. Программирование для Microsoft Windows на C#. В 2-х томах/Пер. с англ. – М.: Издательско-торговый дом “Русская Редакция”, 2002. – 576 + 624 с.
7. П. Наутон, Г. Шилдт. Java 2. Наиболее полное руководство в подлиннике.– СПб.: БХВ-Петербург, 2000. – 1072 с.
8. Рамбо Дж., Якобсон А., Буч Г. UML: специальный справочник. – СПб.: Питер, 2002. – 656 c.