Windows xna что это

Лицензионный ключ активации Windows от

Материал из РУВИКИ — свободной энциклопедии

Microsoft XNA (англ. XNA’s Not Acronymed^[1]) — набор инструментов с управляемой средой времени выполнения (.NET), созданный Microsoft, облегчающий разработку и управление компьютерными играми. XNA стремится освободить разработку игр от написания «повторяющегося шаблонного кода»^[2] и объединить различные аспекты разработки игр в одной системе. Набор инструментов XNA был анонсирован 24 марта 2004 на Game Developers Conference в Сан-Хосе, Калифорния. Первый Community Technology Preview XNA Build был выпущен 14 марта 2006.

Из письма Microsoft от 31 января 2013 стало известно, что новые версии XNA более не будут разрабатываться^[3] и XNA не будет доступен в новом Metro интерфейсе Windows 8, а также на Windows 8 RT^[4].

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

Инструментарий XNA изначально разрабатывался с целью максимально облегчить процесс разработки игр для консоли Xbox и компьютеров, работающих под управлением операционной системы Windows. Вместе с тем, пакет XNA позволит распространить общие сервисы Xbox Live, такие как, например, аутентификация, на игры для персональных компьютеров.

XNA Framework[править | править код]

XNA Framework основывается на нативной реализации .NET Compact Framework 2.0 для разработки игр для Xbox 360 и .NET Framework 2.0 на Windows. Он включает обширный набор библиотек классов, специфичных для разработки игр, поддерживающий максимальное повторное использование кода на всех целевых платформах. Фреймворк выполняется на модификации Common Language Runtime, оптимизированной для игр, чтобы предоставить управляемую среду выполнения. Среда времени выполнения доступна для Windows XP, Windows Vista, Windows 7 и Xbox 360. Так как игры XNA пишутся для среды времени выполнения, они могут быть запущены на любой платформе, поддерживающей XNA Framework с минимальными изменениями или вообще без таковых. Игры, которые запускаются на фреймворке, технически могут быть написаны на любом .NET-совместимом языке, но официально поддерживается только язык программирования C# и среды быстрой разработки XNA Game Studio Express и все версии Visual Studio 2005^[5].

XNA Framework скрывает низкоуровневые технологические детали, связанные с разработкой игры. Таким образом, фреймворк заботится о разнице между платформами, позволяя разработчикам уделять больше внимания смысловому содержимому игры. XNA Framework интегрируется с несколькими инструментами, такими как XACT, для помощи в создании контента. XNA Framework предоставляет поддержку создания и двухмерных, и трёхмерных игр и позволяет использовать возможности контроллеров Xbox 360. Игры фреймворка XNA, предназначенные для платформы Xbox на данный момент могут быть проданы только членам клуба Microsoft XNA Creator’s Club^[5]. Десктопные приложения могут распространяться бесплатно под текущим лицензированием Microsoft.

XNA Content Pipeline[править | править код]

XNA Content Pipeline — набор интегрированных в Visual Studio инструментов управления конвейером ресурсов игры, помогающий при определении, поддержке, отладке и оптимизации конвейера ресурсов игры. Конвейер ресурсов игры (англ. Content Pipeline) описывает процесс, при котором содержимое игры, такое как текстуры и трёхмерные модели, преобразуется в форму, подходящую для использования игровым движком. Content Pipeline помогает идентифицировать зависимости конвейера, а также предоставляет доступ к программному интерфейсу, позволяющему производить дальнейшую обработку данных о зависимостях. Данные о зависимостях могут быть проанализированы для уменьшения размера игры посредством выявления содержимого, которое не используется.

XNA Game Studio[править | править код]

XNA Game Studio — интегрированная среда разработки (IDE) для разработки игр^[6]. Было выпущено пять модификаций:

• XNA Game Studio Professional была запланирована как версия XNA IDE, предназначенная для профессиональных разработчиков игр^[6]. Основанная на Visual Studio 2005 Team System, XNA Studio предоставляет структуру для совместной работы создателей контента, программистов, менеджеров и тестеров. XNA Studio автоматизирует задачи управления проектом, такие как управление ресурсами, слежение за ошибками, автоматизация проекта и работа над спецификациями. Разработка XNA Game Studio Professional остановлена.
• XNA Game Studio Express предназначена для студентов, любителей и независимых разработчиков игр^[5]. Эта модификация доступна для бесплатного скачивания. XNA Game Studio Express предоставляет базовые «стартовые наборы» для быстрой разработки игр типичных жанров, таких как платформер, стратегия в реальном времени и шутер от первого лица. Разработчики могут создавать игры для Windows бесплатно, используя XNA Framework, но для запуска своих игр на Xbox 360 они должны платить членские взносы для доступа к Microsoft XNA Creator’s Club. Первый релиз не предоставлял возможности предоставления скомпилированных бинарных файлов другим игрокам Xbox 360, но в «XNA Game Studio Express 1.0 Refresh» появилась возможность скомпилировать бинарные файлы для Xbox 360 и поделиться ими с другими членами Microsoft XNA Creator’s Club. Первая бета версия XNA Game Studio Express стала доступной для скачивания 30 августа 2006, вторая — 1 ноября 2006. Финальную версию Microsoft выпустила 11 декабря 2006^[7]. 24 апреля 2007 Microsoft выпустила обновление XNA Game Studio Express 1.0 Refresh^[8].
• XNA Game Studio 2.0 была выпущена 13 декабря 2007^[9]. Эта версия предоставила возможность использования со всеми версиями Visual Studio 2005 (включая бесплатную Visual C# 2005 Express Edition), API для создания сетей, использующий Xbox Live, под Windows и на Xbox 360 и лучшее управление устройствами^[10]. Она так же была доступна для бесплатного скачивания на сайте XNA Creator Club.
• XNA Game Studio 3.0 (для Visual Studio 2008 или бесплатной Visual C# 2008 Express Edition) позволила создавать игры, предназначенные для платформы Microsoft Zune и добавила поддержку сообщества Xbox Live. Бета-версия инструментария была выпущена в сентябре 2008^[11], а финальная версия — 30 октября 2008. XNA Game Studio 3.0 поддерживает C# 3.0, LINQ и большинство версий Visual Studio 2008. В XNA Game Studio 3.0 появилось много новых возможностей, таких как тестовый режим, позволяющий создателям добавить необходимую тестовую возможность в свою игру, возможности мультиплейера Xbox LIVE, такие как внутриигровые приглашения, создание кроссплатформенных игр, которые работают под Windows, Xbox 360 и Zune.
• XNA Game Studio 3.1 была выпущена 11 июня 2009. В API добавилась поддержка воспроизведения видео, исправленный аудио API, система Xbox LIVE Party и поддержка игр для использования Xbox 360 Avatars^[12].
• XNA Game Studio 4 была выпущена 16 сентября 2010. Включает в себя поддержку аппаратного 3D ускорения в Windows Phone 7 и интеграцию с Visual Studio 2010.
• XNA Game Studio 4 Refresh была выпущена 6 октября 2011. Была добавлена поддержка для разработки игр, ориентированных на Windows Phone OS 7.1, и разработки игр на Visual Basic.

EULA Microsoft XNA Framework 2.0 специально запрещает распространение коммерческих сетевых игр, которые соединяются с Xbox Live и/или Games for Windows Live без специального соглашения между разработчиком и Microsoft. XNA Game Studio может быть использована для разработки коммерческих игр и других программ для платформы Windows, но код Microsoft для поддержки сети Xbox/Windows Live не может быть использован. В своём проекте XNA можно использовать собственный код поддержки сети.

Игры, созданные с использованием XNA Game studio, на данный момент можно распространять через Xbox Live Community Games^[13][14]. Программное обеспечение также может быть использовано для создания коммерческих игр, предназначенных для Windows.

[править | править код]

Игры для Xbox 360, написанные в XNA Game Studio могут быть представлены Creators Club community, для чего требуется членство, стоящее 49 долларов США за 4 месяца или 99 долларов США в год. Все игры, представленные сообществу, подвергаются равной оценке других разработчиков. Если игра успешно проходит рецензирование, она попадает на Xbox Live Marketplace. Создатели могут установить цену в 200, 400 или 800 points для своей игры. Разработчик получает 70 % полной выручки от объёма продаж своей игры в качестве основы. Microsoft изначально планировали брать дополнительный процент выручки, если они предоставляют дополнительный маркетинг для игры, но эта политика была отменена в марте 2009, оставив стандартную цену без изменений^[15].

Microsoft также распространяет «тестовые аккаунты» для образовательных учреждений в рамках их программы DreamSpark. Эти аккаунты позволяют студентам разрабатывать игры для Xbox 360, но, чтобы выставить игру на Marketplace, требуется привилегированный аккаунт.

Существует проект MonoGame, представляющий собой кроссплатформенную open-source реализацию XNA с дополнительными возможностями.

Позже, на основе MonoGame был создан проект FNA, который является полнофункциональной реализацией XNA с открытым исходным кодом. Цель FNA — сохранить игровую библиотеку XNA путем повторной реализации её самой.^[16]

• Официальный сайт (англ.)
• Центр разработки XNA (англ.)
• Объёмная книга по основам работы с XNA, включает как 2d так и 3d графику
• Курс «Введение в XNA» на INTUIT

Картинка с сайта: habr.com

Привет всем начинающим геймдевелоперам и просто хорошим людям. Сегодня, я хочу познакомить вас с замечательным фреймворком XNA (набор инструментов с управляемой средой времени выполнения dotNet). Программировать мы будем на C#.
Для того, чтобы познакомить вас с XNA ближе, я предлагаю написать простую «музыкальную» 2D игрушку. Остальное под катом.

Краткое описание на википедии

Microsoft XNA (англ. XNA’s Not Acronymed) — набор инструментов с управляемой средой времени выполнения (.NET), созданный Microsoft, облегчающий разработку и управление компьютерными играми. XNA стремится освободить разработку игр от написания «повторяющегося шаблонного кода»

Что для этого нам будет нужно?

1) Свежий DirectX (например Июнь 2010)
2) Microsoft Visual C# 2010 EXPRESS (бесплатная лицензия)
3) Microsoft XNA Game Studio 4.0

Что предполагается разобрать и сделать на этом уроке?

• Подключить сборки XNA Framework
• Создать пустое приложение с закрашиванием фона
• Научиться подгружать контент
• Научиться работать со звуком
• Научиться работать с графикой

Какую игру мы будем реализовывать?

Механика игры проста до безумия. Смысл будет построен на музыке, в случае с этой игрой, будет использована композиция Исаака Шепарда — Leaves in the Wind. Нужно будет ловить мышкой «ноты», скорость и кол-во которых будут зависимы от текущей позиции в музыки, грубо говоря игровой «визуализатор». Для разнообразия существуют 5 тип нот: обычные, красные (враги), пурпурные (мощь), мигающие (превращает все в желтые), желтые (увеличивает скорость набора очков и размеры).

Собираем вещи пустой проект

Для начала ставим все необходимые компоненты по порядку, затем запускаем Microsoft Visual C# 2010 EXPRESS и создаем проект Windows Game (4.0) и называем его music_catch:

Картинка с сайта: habr.com

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

Проект music_catch — «логика» нашего приложения.
Game1.cs — главный класс приложения, унаследован он от Microsoft.Xna.Framework.Game
Program.cs — «точка входа» в приложение, он нам не интересен.
Проект music_catchContent — «контент» нашего приложения, туда мы будем складывать ресурсы.

Более подробно взглянем на Game1.cs
В нем можно выделить основные функции, такие как:
Game1() — конструктор класса.
Initialize() — инициализация приложения.
LoadContent() — загрузка контента.
UnloadContent() — выгрузка контента.
Update(GameTime gameTime) — обновление логики приложения (например физики, etc)
Draw(GameTime gameTime) — отрисовка игры. ВНИМАНИЕ, любые операции с рисованием нужно проводить тут и только тут.

Пустой проект собран, идем дальше, добавляем ресурсы в приложение, все нужные ресурсы «кидаем» в папку music_catch\music_catchContent. В нашем случае — пять PNG файлов и одно музыкальное сопровождение. Добавляем это все в проект:

Картинка с сайта: habr.com

Там же создаем шрифт, в теле SpriteFont1.spritefont указываем имя и размер:

<FontName>Segoe UI Mono</FontName>
<Size>14</Size>

Создаем переменные для будущего контента:

private List<Texture2D> MelList;
private Texture2D mouse;
private Song song;
private SpriteFont font;

И грузим его в LoadContent():

MelList = new List<Texture2D>();
for(int a = 1; a <= 5; a++)
MelList.Add(Content.Load<Texture2D>("mel" + a));

mouse = Content.Load<Texture2D>("mouse");
song = Content.Load<Song>("Leaves_in_the_Wind");
font = Content.Load<SpriteFont>("SpriteFont1");

Кстати, подгружается контент следующим образом: вызывается Content.Load<>(«asset»);
В треугольных скобках указывается процессор контента, в нашем случае это Texture2D, Song, SpriteFont. Можно использовать свои процессоры, об этом я расскажу как-нибудь потом.

Контент подгружен, идем в конструктор Game1() и пишем:

graphics = new GraphicsDeviceManager(this);
           
graphics.PreferredBackBufferWidth = 800; // ширина приложения
graphics.PreferredBackBufferHeight = 600; // высота приложения
graphics.IsFullScreen = false; // флаг полноэкранного приложения
graphics.ApplyChanges(); // применяем параметры

Content.RootDirectory = "Content";

Приложение инициализировано.

Пишем «игровую логику»

Теперь нам нужно создать контроллер системы частиц и сами частицы (ноты), которые мы будем виртуозно ловить мышкой.
Создаем два класса: Catcher (сами частицы) и CatcherHolder (система частиц).

Листинг Catcher с комментариями:

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;

namespace MusicCatch
{
    public class Catcher
    {

        public Texture2D Texture { get; set; }        // Текстура частицы
        public Vector2 Position { get; set; }        // Позиция частицы
        public Vector2 Velocity { get; set; }        // Скорость частицы
        public float Angle { get; set; }            // Угол поворота частицы
        public float AngularVelocity { get; set; }    // Угловая скорость частицы
        public Color Color { get; set; }            // Цвет частицы
        public float Size { get; set; }                // Размер частицы
        public int TTL { get; set; }                // Время жизни частицы

        private float RComponent; // Красный компонент RGB
        private float GComponent; // Зеленый компонент RGB
        private float BComponent; // Синий компонент RGB
        public int type; // Тип частицы
        private Random random; // Генератор случайных чисел

        public Catcher(Texture2D texture, Vector2 position, Vector2 velocity,
            float angle, float angularVelocity, int type, float size, int ttl)
        {
		// Установка переменных из конструктора
            Texture = texture;
            Position = position;
            Velocity = velocity;
            Angle = angle;
            AngularVelocity = angularVelocity;
            this.type = type;
            Size = size;
            TTL = ttl;

            SetType(type); // Установка цвета под определенный тип

        }

        public void ApplyImpulse(Vector2 vector) // Добавление импульса (используется бонусом)
        {
            Velocity += vector;
        }

        public void Update() // Обновление единичной частички
        {
            TTL--;
            Position += Velocity;
            Angle += AngularVelocity;

            if (type != -1)
            {
                Velocity = new Vector2(Velocity.X, Velocity.Y - .1f);
                Size = (10 + Velocity.Y) / 20;
                if(Size > 0.8f) Size = 0.8f;
            } 

            if (type == 0)
            {
                GComponent -= 0.005f;
                BComponent += 0.005f;

                Color = new Color(RComponent, GComponent, BComponent);
            }
            else if (type == 4)
            {
                Color = new Color((float)(1f * random.NextDouble()), (float)(1f * random.NextDouble()), (float)(1f * random.NextDouble()));
            }
        }

        public void Draw(SpriteBatch spriteBatch) // Прорисовка частички
        {
            Rectangle sourceRectangle = new Rectangle(0, 0, Texture.Width, Texture.Height);
            Vector2 origin = new Vector2(Texture.Width / 2, Texture.Height / 2);

            spriteBatch.Draw(Texture, Position, sourceRectangle, Color,
                Angle, origin, Size, SpriteEffects.None, 0f);
        }

        public void SetType(int type) // Установка цвета частички
        {
            this.type = type;
            Color StartColor = new Color(1f, 1f, 1f);

            switch (type)
            {
                case 0: StartColor = new Color(0f, 1f, 0f); break; // Обычная
                case 1: StartColor = new Color(1f, 0f, 0f); break; // Красная
                case 2: StartColor = new Color(1f, 0f, 1f); break; // Пурпурная
                case 3: StartColor = new Color(1f, 1f, 0f); break; // Желтая
                case 4: random = new Random(); break; // Мигающая
            }

            RComponent = ((int)StartColor.R) / 255f;
            GComponent = ((int)StartColor.G) / 255f;
            BComponent = ((int)StartColor.B) / 255f;

            Color = new Color(RComponent, GComponent, BComponent);

            if (type == -1)
            {
                Color = new Color(1f, 1f, 1f, 0.1f);
            }

        }
    }
}

Листинг CatcherHolder с комментариями:

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;

namespace MusicCatch
{
    class CatcherHolder
    {
        private Random random; // Генератор случайных чисел

        public List<Catcher> particles; // Массив частичек (Catcher)
        private List<Texture2D> textures; // Массив текстур

        public List<float> accomulator { get; set; } // Массив float-значений, что такое и зачем нужен accomulator — объясню чуть позже.

        public CatcherHolder(List<Texture2D> textures)
        {
            this.textures = textures;
            this.particles = new List<Catcher>();

            random = new Random();

            accomulator = new List<float>(); // Инициализируем массив и записываем во все 128 ячеек — 1.0f
            for (int a = 0; a < 128; a++)
            {
                accomulator.Add(1.0f);
            }
        }
	// Генерация одной частички
	// Wave - волна, число от 0f до ширины экрана.
	 private Catcher GenerateNewParticle(float Wave) 
        {
            Texture2D texture = textures[random.Next(textures.Count)]; // Берем случайную текстуру из массива
            Vector2 position = new Vector2(Wave, 0); // Задаем позицию
            Vector2 velocity = new Vector2((float)(random.NextDouble()  - 0.5), (float)(random.NextDouble() * 10)); // Случайное ускорение, 0.5f для X и 10f для Y
            float angle = 0; // Угол поворота = 0
            float angularVelocity = 0.05f * (float)(random.NextDouble()*2 - 1 ); // Случайная скорость вращения
            Color color = new Color(0f, 1f, 0f); // Зеленый цвет (изменится цвет уже в самом Catcher)
            float size = (float)random.NextDouble()*.8f + .2f; // Случайный размер
            int ttl = 400; // Время жизни в 400 (400 актов рисования живет частица, т.е. 400 / 60 — 6 с лишним секунд.

            int type = 0; — изначальный тип 0

		// Вероятность появления
	     if (random.Next(10000) > 9900) // враг
                type = 1;
            else if (random.Next(10000) > 9950) // желтый
                type = 3;
            else if (random.Next(10000) > 9997) // пурпурный
                type = 2;
            else if (random.Next(10000) > 9998) // мигающий
                type = 4;
	
            return new Catcher(texture, position, velocity, angle, angularVelocity, type, size, ttl); // Создаем частичку и возвращаем её
        }

	// Генерация желтых частичек при касании с красной частичкой
	 public void GenerateYellowExplossion(int x, int y, int radius)
        {
            Texture2D texture = textures[random.Next(textures.Count)];

            Vector2 direction = Vector2.Zero;
            float angle = (float)Math.PI * 2.0f * (float)random.NextDouble();
            float length = radius * 4f;

            direction.X = (float)Math.Cos(angle);
            direction.Y = -(float)Math.Sin(angle);

            Vector2 position = new Vector2(x, y) + direction * length;

            Vector2 velocity = direction * 4f;
            
            float angularVelocity = 0.05f * (float)(random.NextDouble() * 2 - 1);

            float size = (float)random.NextDouble() * .8f + .2f;
            int ttl = 400;

            int type = 3;
            particles.Add(new Catcher(texture, position, velocity, 0, angularVelocity, type, size, ttl));
        }

	// "Музыкальный" импульс, создание частички
        public void Beat(float Wave)
        {
            particles.Add(GenerateNewParticle(Wave));
        }

        public void Update() // Обновление всех частиц
        {
           
           for (int particle = 0; particle < particles.Count; particle++)
            {
                particles[particle].Update();
                if (particles[particle].Size <= 0 || particles[particle].TTL <= 0)
                {
			// Если частичка дохлая или размер нуль или меньше, удаляем её
                    particles.RemoveAt(particle);
                    particle--;
                }
            }
	
	// Обновляем аккумулятор, если значения ячейки меньше 1f, то добавляем значение, указанное в статическом классе Constants — ACCUMULATE_SPEED, листинг Constanst - ниже.
            for (int a = 0; a < 128; a++)
                if (accomulator[a] < 1.0f)
                    accomulator[a] += Constanst.ACCUMULATE_SPEED; 
            
        }

        public void Draw(SpriteBatch spriteBatch)
        {
		// Прорисовываем все частички, важно указать BlendState.Additive, чтобы частички были более "мягкие".
            spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.Additive);
            for (int index = 0; index < particles.Count; index++)
            {
                particles[index].Draw(spriteBatch);
            }
            spriteBatch.End();
        }
    }
}

Листинг Constant.cs:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MusicCatch
{
    public class Constanst
    {
        public const float BEAT_COST = .4f; // "Стоимость" частички, отнимается у аккумулятора при генерации новой частички
        public const float ACCUMULATE_SPEED = .01f; // Скорость аккумуляции
        public const float BEAT_REACTION = .5f; // Значение реакции на "бит" в музыке
        public const float ACCOMULATOR_REACTION = .5f; // Разрешает создавать новую частичку только тогда, когда значения больше реакции аккумулятора
    }
}

Объясню, что за загадочный аккумулятор и зачем он нужен. Поговорим о «музыкальном» спектре.

Музыкальный сигнал – пища для аудиосистемы. Точнее – не так. Динамики музыку не слушают, ее восстанавливает наш мозг, получая сложный сигнал, содержащий множество частотных составляющих.
Дак вот, идея такая, слушать «частоты» каждый Update и записывать их в какой-нибудь, например, VisualizationData. Проще говоря, в массив из 128 элементов, которые изменяются от 0f до 1f.

Как этим можно воспользоваться?
Каждый Update: значения в массиве меняются в соответствии с музыкой, нам нужно проверить все 128 элементов, если значение элемента больше чем 0.6f, вызываем Beat-функцию и передаем ей Wave (индекс элемента массива, в котором произошло событие). Все бы хорошо, можно в Beat создавать частичку-ноту. Но представим, что у нас выполняется три Update’а подряд, в котором в одном и том же индексе — значение > 0.6f, как итог будет 100500 частичек за секунду. Чтобы таких вещей не происходило, можно использовать аккумулятор. Смысл его прост: при Beat’е у ячейки массива-аккумулятора соотвествующего индексу Wave отнимается константа BEAT_COST. Каждый Update ко всем элементам аккумулятора прибавляется ACCUMULATE_SPEED. Перед тем, как вызвать Beat проверяется выполняется ли условие — значение аккумулятора > ACCOMULATOR_REACTION, если да, то вызываем Beat. Это решает проблему.

Кстати, BEAT_REACTION — значение, после которых нужно проверять, стоит ли вызывать Beat.

Дальше приведу полный листинг GameLogic (Game1). Много кода, но постараюсь расписать в комментариях.

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;

namespace MusicCatch
{
  public class Game1 : Microsoft.Xna.Framework.Game
    {
        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;

        private List<Texture2D> MelList;
        private Texture2D mouse;

        private CatcherHolder m_cHolder;

        MediaLibrary mediaLibrary; // Грубо говоря "проигрыватель"
        Song song; // Сама музыка
        VisualizationData visualizationData;

        SpriteFont font;

        private int scores = 0; // очки
        private float self_size = 1f; // размер "игрока"
        private int xsize = 1; // множитель очков

        private float power = 0f; // переменная для пурпурного бонуса
        private float activity = 0f; // переменная для активности игрока

        public Game1()
        {
            graphics = new GraphicsDeviceManager(this);
           
            graphics.PreferredBackBufferWidth = 800;
            graphics.PreferredBackBufferHeight = 600;
            graphics.IsFullScreen = false;
            graphics.ApplyChanges();

            Content.RootDirectory = "Content";

	// Создаем переменные
            mediaLibrary = new MediaLibrary();
            visualizationData = new VisualizationData();

            scores = 0;

        }

        protected override void Initialize()
        {
            m_cHolder = new CatcherHolder(MelList);

            MediaPlayer.Play(song); // начинаем играть музыку
            MediaPlayer.IsVisualizationEnabled = true; // включаем визуализатор

 	     base.Initialize();
        }

        protected override void LoadContent()
        {
            spriteBatch = new SpriteBatch(GraphicsDevice);

            MelList = new List<Texture2D>();

            for(int a = 1; a <= 5; a++)
            MelList.Add(Content.Load<Texture2D>("mel" + a));

            mouse = Content.Load<Texture2D>("mouse");

            song = Content.Load<Song>("Leaves_in_the_Wind");

            font = Content.Load<SpriteFont>("SpriteFont1");
        }

        protected override void UnloadContent()
        {
        }

        protected override void Update(GameTime gameTime)
        {
           m_cHolder.Update();
           MediaPlayer.GetVisualizationData(visualizationData); // получаем данные 
           // "Прогоняем" массив с частотами, выполняем условия
            for (int a = 0; a < 128; a++)
            {
                if (visualizationData.Frequencies[a] > Constanst.BEAT_REACTION && m_cHolder.accomulator[a] > Constanst.ACCOMULATOR_REACTION)
                {
                    m_cHolder.Beat(a * 3.125f * 2); // вызываем "бит", которые создает частичку.
                    m_cHolder.accomulator[a] -= Constanst.BEAT_COST; // убавляем аккумулятор
                }
            }
	// проверяем, есть ли бонус, который тянет к игроку все ноты
            if (power > 0f)
            {
                for (int particle = 0; particle < m_cHolder.particles.Count; particle++)
                {
                    if (m_cHolder.particles[particle].type != 1) // если не враг, то тянем
                    {
                        float body1X = m_cHolder.particles[particle].Position.X;
                        float body1Y = m_cHolder.particles[particle].Position.Y;
                        float body2X = (float)Mouse.GetState().X;
                        float body2Y = (float)Mouse.GetState().Y;

                        float Angle = (float)Math.Atan2(body2X - body1X, body2Y - body1Y) - ((float)Math.PI / 2.0f); // находим угол к игроку

                        float Lenght = (float)(5000f * power) / (float)Math.Pow((float)Distance(body1X, body1Y, body2X, body2Y), 2.0f); // находим силу

                        m_cHolder.particles[particle].ApplyImpulse(AngleToV2(Angle, Lenght)); // даем пинка ноте
                    }
                }
                power -= 0.001f; // убавляем бонус
            }

            activity -= 0.001f; // убавляем активность игрока

            if (activity < 0.0f)
                activity = 0.0f;
            else if (activity > 0.5f) activity = 0.5f;
		// Держим активность игрока от 0f до .5f

		// Проверяем столкновения двух кругов: игрока и нот
            for (int particle = 0; particle < m_cHolder.particles.Count; particle++)
            {
                int x = (int)m_cHolder.particles[particle].Position.X;
                int y = (int)m_cHolder.particles[particle].Position.Y;
                int radius = (int)(16f * m_cHolder.particles[particle].Size);

                if (circlesColliding(Mouse.GetState().X, Mouse.GetState().Y, (int)(16f * self_size), x, y, radius))
                {

                    scores += (int)(10f * m_cHolder.particles[particle].Size * xsize); // добавляем очки, которые зависят от размера ноты и множителя
                    activity += 0.005f; // добавляем активность
                    int type = m_cHolder.particles[particle].type;

			// выполняем всякие условия, которые возникают при коллизии
                    switch (type)
                    {
                        case 3: // желтый
                            self_size += 0.1f;
                            xsize += 1;
				
				// увеличиваем множитель и размер игрока
                            if (self_size > 4.0f)
                                self_size = 4.0f;
                        break;

                        case 2: // пурпурный
                            power = 1f; // даем бонус игроку, который все ноты притягивает к себе
				
                        break;

                        case 4: // мигающий
                        for (int b = 0; b < m_cHolder.particles.Count; b++)
                            m_cHolder.particles[b].SetType(3); // устанавливает всем нотам тип — желтый
                                
                            
                        break;

                        case 1: // красный (враг)
                            for(int a = 1; a < xsize; a++)
                            m_cHolder.GenerateYellowExplossion(Mouse.GetState().X, Mouse.GetState().Y, (int)(16f * self_size)); 

                            xsize = 1;
                            self_size = 1f;
                            scores -= (int)(scores / 4);
                        break;

                    }


			// удаляем частичку
                    m_cHolder.particles[particle].TTL = 0; 
                    m_cHolder.particles.RemoveAt(particle);
                    particle--;
                }
            }

            base.Update(gameTime);
        }

              protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice.Clear(Color.Black);
            
            m_cHolder.Draw(spriteBatch); // рисуем CatcherHolder

            spriteBatch.Begin();

            Rectangle sourceRectangle = new Rectangle(0, 0, mouse.Width, mouse.Height); // размеры текстуры
            Vector2 origin = new Vector2(mouse.Width / 2, mouse.Height / 2); // offset текстуры
            Vector2 mouse_vector = new Vector2(Mouse.GetState().X, Mouse.GetState().Y); // вектор(позиция) мышки

            string xtext = "x" + xsize.ToString(); // текст
            Vector2 text_vector = font.MeasureString(xtext) / 2.0f; // вычисления offset'a текста

            spriteBatch.Draw(mouse, mouse_vector, sourceRectangle, new Color(0.5f - power/2.0f + activity, 0.5f, 0.5f - power/2.0f), 0.0f, origin, self_size, SpriteEffects.None, 0f); // рисуем игрока
            spriteBatch.DrawString(font, xtext, mouse_vector - text_vector, Color.White); // рисуем множитель

            spriteBatch.DrawString(font, "Score: " + scores.ToString(), new Vector2(5, graphics.PreferredBackBufferHeight - 34), Color.White); // рисуем очки
            spriteBatch.End();

            base.Draw(gameTime);
        }

        // возвращает, столкнулись ли два круга или нет
        bool circlesColliding(int x1, int y1, int radius1, int x2, int y2, int radius2)
        {
            
            int dx = x2 - x1;
            int dy = y2 - y1;
            int radii = radius1 + radius2;
            if ((dx * dx) + (dy * dy) < radii * radii)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
	// функция перевода угла в вектор
        public Vector2 AngleToV2(float angle, float length)
        {
            Vector2 direction = Vector2.Zero;
            direction.X = (float)Math.Cos(angle) * length;
            direction.Y = -(float)Math.Sin(angle) * length;
            return direction;
        }

	// дистанция
        public float Distance(float x1, float y1, float x2, float y2)
        {
            return (float)Math.Sqrt((float)Math.Pow(x2 - x1, 2) + (float)Math.Pow(y2 - y1, 2));
        }
    }
}

Вот такая простенькая игрушка получается. На конечной машине пользователя должен быть установлен XNA 4.0 и .NET;

Ссылки: сама игра (директ) | исходники (директ) | XNA Framework End-user

Скриншот:

Картинка с сайта: habr.com

P.S. Идея не моя, такая игра уже была выпущена под flash. Эта игра писалась исключительно для статьи, соответственно дальнейшего развития она не получит.
P.S.S. Так же помогу разобраться в XNA / уроке, для этого пишите мне в личку на хабре или на контакты, которые есть в профиле.

Цель лекции: Обзор пакета Microsoft XNA, перспективы его применения в данной системе.

Из предыдущих лекций мы помним, что Microsoft XNA— набор инструментов с управляемой средой времени выполнения (.NET), созданный Microsoft, облегчающий разработку и управление компьютерными играми. XNA стремится освободить разработку игр от написания «повторяющегося шаблонного кода» и объединить различные аспекты разработки игр в одной системе. Набор инструментов XNA был анонсирован 24 марта 2004 на Game Developers Conference в Сан-Хосе, Калифорния.

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

Инструментарий XNA изначально разрабатывался с целью максимально облегчить процесс разработки игр для консоли Xbox и компьютеров, работающих под управлением операционной системы Windows. Вместе с тем, пакет XNA позволит распространить общие сервисы Xbox Live, такие как, например, аутентификация, на игры для персональных компьютеров. Инструментарий XNA позволяет Microsoft конкурировать с Sony на рынке видеоигр для следующего поколения игровых приставок.

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

В XNA даже нет встроенных шрифтов. И приложение на XNA, выполняющееся на телефоне, не может использовать те же встроенные шрифты телефона, что и программы на Silverlight, как это можно было бы предположить. Silverlight применяет векторные шрифты TrueType, а XNA ничего не знает о таких экзотических концепциях. Для XNA все, включая шрифты, является растровыми изображениями.

Если в приложении на XNA требуется использовать определенный шрифт, он должен быть встроен в исполняемый файл как коллекция растровых изображений для каждого символа. XNA Game Studio (которая интегрирована в Visual Studio) очень упрощает сам процесс встраивания шрифта, но тут возникают некоторые серьезные правовые проблемы.

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

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

Картинка с сайта: intuit.ru

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

В Visual Studio в меню File выберите New и Project.

В левой части диалогового окна выберите Visual C# и XNA Game Studio 4.0. В середине выберите Windows Phone Game (4.0). Задайте месторасположение и имя проекта, XnaHelloPhone.

Visual Studio создает два проекта, один для логики приложения и другой для его содержимого. Приложения на XNA обычно включают большой объем содержимого, которым преимущественно являются растровые изображения и трехмерные модели, но также и шрифты.

Чтобы добавить шрифт в это приложение, щелкните правой кнопкой мыши проект, созданный для содержимого (он обозначен «XnaHelloPhoneContent (Content)»), и во всплывающем меню выберите Add (Добавить) и New Item (Новый элемент). Выберите sprite Font, оставьте имя файла как есть, SpriteFont1.spritefont, и щелкните Add.

Слово «спрайт» (» sprite» в переводе на русский означает «эльф») широко распространено в игровых приложениях и обычно обозначает небольшое растровое изображение, которое может очень быстро перемещаться (так же как эльфы, живущие в волшебном лесу). В XNA даже шрифты являются спрайтами.

SpriteFont1.spritefont появится в списке файлов каталога Content, и вы можете редактировать изобилующий комментариями XML-файл, описывающий шрифт.

Проект XNA: XnaHelloPhone Файл: SpriteFont1.spritefont (полностью за исключением комментариев)

<?xml version="1.0" encoding="utf-8"?>
<XnaContent xmlns:Graphics="Microsoft.Xna.Framework.Content.Pipeline.Graphics">
  <Asset Type="Graphics:FontDescription">

    <FontName>Segoe UI Mono</FontName>

    <Size>14</Size>

    <Spacing>0</Spacing>
    
    <UseKerning>true</UseKerning>

    <Style>Regular</Style>

    <CharacterRegions>
      <CharacterRegion>
        <Start>&#32;</Start>
        <End>&#126;</End>
      </CharacterRegion>
    </CharacterRegions>
  </Asset>
</XnaContent>

Между тегами FontName указан шрифт Segoe UI Mono, но его можно заменить любым другим шрифтом, из приведенных ранее. Если желаете использовать Pericles Light, укажите его полное имя, но для Miramonte Bold, Pescadero Bold или Segoe UI Mono Bold необходимо написать просто Miramonte, Pescadero или Segoe UI Mono и ввести Bold (Полужирный) между тегами Style (Стиль).

Bold может использоваться и для других шрифтов, но для них он будет синтезирован, тогда как для Miramonte, Pescadero или Segoe UI Mono будет использоваться специально разработанный полужирный шрифт.

Теги Size (Размер) обозначают размер шрифта в пунктах. В XNA, как и в Silverlight, координаты и размеры задаются в пикселах, но в XNA за основу при преобразовании между пикселами и пунктами взято разрешение 96 DPI. Для XNA-приложения 14 шрифт равен 18-2/3 пикселам. Это очень близко к шрифту размером 15 пунктов или с FontSize равным 20 пикселов в Silverlight для Windows Phone.

В разделе CharacterRegions (Диапазоны символов) файла указываются диапазоны шестнадцатеричных кодировок Unicode. По умолчанию используется диапазон от 0x32 до 0x126, что включает все обычные символы набора символов ASCII.

ASCII (англ. American Standard Code for Information Interchange) — американская стандартная кодировочная таблица для печатных символов и некоторых специальных кодов. ASCII представляет собой кодировку для представления десятичных цифр, латинского и национального алфавитов, знаков препинания и управляющих символов.

SpriteFont1.spritefont не является достаточно описательным именем. Если сохраняются стандартные настройки шрифта, переименуйте файл в Segoe14.spritefont. Если взглянуть на свойства этого файла – щелкните правой кнопкой мыши имя файла и выберите Properties – можно увидеть, что значением Asset Name (Имя ресурса) является имя файла без расширения: Segoe14. Значение Asset Name используется для ссылки на шрифт в приложении. Если хотите запутать себя, можете изменить Asset Name и задать ему значение, отличное от имени файла.

Изначально проект XNAHelloPhone включает два C#-файла: Program.cs и Game1.cs. Первый очень простой и, как выясняется, не имеет отношения к играм для Windows Phone 7. Директива препроцессора активирует класс Program (Программа), только если определен символ WINDOWS или XBOX. При компиляции программ для Windows Phone вместо них задается символ WINDOWS_PHONE.

Чаще всего при создании небольших игр основная часть времени уходит на файл Game1.cs. Класс Game1 наследуется от Game (Игра). Первоначально в нем определены два поля: graphics (графические элементы) и spriteBatch (Пакет спрайтов). К этим двум полям добавим еще три:

Проект XNA: XnaHelloPhone Файл: Game1.cs (фрагмент, демонстрирующий поля)

namespace XnaHelloPhone
{
    public class Game1 : Microsoft.Xna.Framework.Game
    {
        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;
        string text = "Hello, World!";
        SpriteFont segoe14;
        Vector2 textPosition;
…………….

В этих трех новых полях просто указан текст для отображения, используемый для этого шрифт и месторасположения текста на экране. Координаты задаются в пикселах относительно верхнего левого угла экрана. Структура Vector2 имеет два поля: X и Y, типа float (число с плавающей точкой).

В целях обеспечения лучшей производительности в XNA все значения с плавающей точкой берутся с одинарной точностью. (В Silverlight – с двойной точностью.) Структура Vector2 часто используется для задания точек, размеров и даже векторов в двухмерном пространстве.

При запуске игры на телефоне, создается экземпляр класса Game1 и выполняется конструктор Game1. Рассмотрим стандартный код:

Проект XNA: XnaHelloPhone Файл: Game1.cs (фрагмент)

public Game1()
        {
            graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";

                        TargetElapsedTime = TimeSpan.FromTicks(333333);
        }

По умолчанию частота кадров для Windows Phone составляет 30 кадр/с.

Первое выражение обеспечивает инициализацию поля graphics.

Во втором выражении для Game определяется свойство Content (Содержимое) типа ContentManager (Диспетчер содержимого), и RootDirectory (Корневой каталог) является свойством этого класса. Значение «Content» этого свойства соответствует папке Content, в которой хранится шрифт Segoe размером 14 пунктов.

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

Когда экземпляр Game1 создан, вызывается его метод Run (Выполнить), и базовый класс Game инициирует процесс запуска игры. Один из первых шагов – вызов метода Initialize (Инициализировать), который может быть перегружен в производных от Game классах. XNA Game Studio автоматически формирует скелетный метод, в который мы не будем ничего добавлять:

Проект XNA: XnaHelloPhone Файл: Game1.cs (фрагмент)

protected override void Initialize()
        {
            // TODO: Add your initialization logic here

            base.Initialize();
        }

В методе Initialize шрифт или любое другое содержимое не должно загружаться. Это происходит несколько позже, когда базовый класс вызывает метод LoadContent (Загрузить содержимое). Добавим несколько строк, чтобы содержимое соответствовало следующему:

Проект XNA: XnaHelloPhone Файл: Game1.cs (фрагмент)

protected override void LoadContent()
        {
            spriteBatch = new SpriteBatch(GraphicsDevice);

            segoe14 = this.Content.Load<SpriteFont>("Segoe14"); 
            Vector2 textSize = segoe14.MeasureString(text);
            Viewport viewport = this.GraphicsDevice.Viewport; 

textPosition = new Vector2((viewport.Width - textSize.X) / 2, (viewport.Height - textSize.Y) / 2);
        }

Первое выражение данного метода формируется автоматически. Вскоре мы увидим, как этот объект spriteBatch используется для вывода спрайтов на экран.

Как можно заметить, перед всеми именами свойств, таких как Content и GraphicsDevice (Графическое устройство), было поставлено ключевое слово this, чтобы напомнить, что это свойства, а не статические классы. Как уже говорилось, свойство Content типа ContentManager. Универсальный метод Load (Загрузить) обеспечивает загрузку содержимого в приложение, в данном случае, это содержимое типа SpriteFont. Имя, указанное в кавычках, соответствует Asset Name, указанному в свойствах содержимого. Это выражение обеспечивает сохранение результата в поле segoe14 типа SpriteFont.

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

У класса SpriteFont есть чрезвычайно удобный метод MeasureString (Измерить строку), возвращающий объект Vector2 с размером конкретной текстовой строки в пикселах. (Для шрифта Segoe UI Mono размером 14 пунктов, высота которого эквивалентна 18-2/3 пикселам, метод MeasureString возвратит высоту 28 пикселов.)

Как правило, для получения размера экрана в приложении на XNA используется свойство Viewport (Окно просмотра) класса GraphicsDevice. Оно доступно через свойство GraphicsDevice класса Game и предоставляет свойства Width (Ширина) и Height (Высота).

После этого довольно просто вычислить textPosition (Положение текста) – координаты точки относительно верхнего левого угла окна просмотра, в которой будет располагаться верхний левый угол текстовой строки.

На этом этап инициализации программы завершается, и начинается фактическое действие. Приложение входит в игровой цикл. Синхронно с обновлением экрана, которое происходит с частотой 30 кадров в секунду, в приложении вызываются два метода: Update (Обновить) и за ним Draw (Рисовать). Снова и снова: Update, Draw, Update, Draw, Update, Draw…. (На самом деле, все несколько сложнее; методу Update необходимо 1/30 секунды для выполнения.)

Метод Draw обеспечивает отрисовку образов на экране. И это все, что он может делать. Все подготовительные вычисления для отрисовки должны осуществляться в методе Update. Метод Update подготавливает программу к выполнению метода Draw. Очень часто приложения на XNA реализуют перемещение спрайтов по экрану на основании пользовательского ввода. Для телефона пользовательский ввод осуществляется преимущественно посредством сенсорного ввода. Вся обработка пользовательского ввода также должна происходить во время выполнения метода Update.

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

В нашем приложении XnaHelloPhone метод Update абсолютно тривиальный. Отображаемый текст зафиксирован в одной единственной точке. Все необходимые вычисления уже выполнены в методе LoadContent. Поэтому оставляем метод Update без изменений, просто в том виде, в каком он был изначально создан XNA Game Studio:

Проект XNA: XnaHelloPhone Файл: Game1.cs (фрагмент)

protected override void Update(GameTime gameTime)
        {
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
                this.Exit();

            base.Update(gameTime);
        }

В формируемом по умолчанию коде для проверки события нажатия кнопки Back использует статический класс GamePad (Игровой планшет). Это событие является сигналом к выходу из игры.

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

Проект XNA: XnaHelloPhone Файл: Game1.cs (фрагмент)

protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice.Clear(Color.CornflowerBlue);

            base.Draw(gameTime);
        }

Васильковый цвет (CornflowerBlue) приобрел культовый статус в сообществе разработчиков на XNA. При работе над программой на XNA увидеть голубой экран очень утешительно, поскольку это означает, что программа, по крайней мере, дошла до метода Draw. Но в целях энергосбережения при использовании ОСИД-экранов желательно применять более темные фоны. Мы сделали фон темно-синим. Как и Silverlight, XNA поддерживает 140 цветов, которые уже считаются стандартными. Выводимый текст будет белого цвета:

Проект XNA: XnaHelloPhone Файл: Game1.cs (фрагмент)

protected override void Draw(GameTime gameTime)
        {
GraphicsDevice.Clear(Color.Navy); 

            spriteBatch.Begin(); 
            spriteBatch.DrawString(segoe14, text, textPosition, Color.White); 
            spriteBatch.End();

            base.Draw(gameTime);
        }

Спрайты выводятся на экран пакетами в составе объекта SpriteBatch, который был создан во время вызова метода LoadContent. Между вызовами Begin (Начало) и End (Конец) может осуществляться множество вызовов метода DrawString (Отрисовать строку) для отрисовки текста и Draw для отрисовки растровых изображений. Вызываться могут только эти методы. В данном конкретном вызове DrawString указан шрифт, выводимый текст, местоположение верхнего левого угла текста относительно верхнего левого угла экрана и цвет. Результат выполнения программы:

Обратите внимание, что по умолчанию программы на Silverlight отображаются в портретном режиме, а программы на XNA – в альбомном. Повернем телефон или эмулятор (с помощью панели в правом верхнем углу):

Картинка с сайта: intuit.ru

Рис.
4.3.
Результат программы, портретный режим

Ключевые термины

ASCII (англ. American Standard Code for Information Interchange) — американская стандартная кодировочная таблица для печатных символов и некоторых специальных кодов. ASCII представляет собой кодировку для представления десятичных цифр, латинского и национального алфавитов, знаков препинания и управляющих символов.

Sprite— ( в переводе на русский означает «эльф») широко распространено в игровых приложениях слово,обозначающее небольшое растровое изображение, которое может очень быстро перемещаться.

Краткие итоги

В данной лекции мы:

• ближе познакомились с Microsoft XNA, её возможностями и областью применения;
• написали первую программу на XNA;
• рассмотрели стандартные шрифты, предоставляемые Microsoft.

Набор для практики

Упражнения

Добавьте к нашей программе вторую строчку с другим текстом, располагающуюся немного ниже первой.