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

Давайте начнем с создания двух новых файлов: Entity.cpp и Entity.h. Откройте заголовочный файл и добавьте следующее:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

#include <vector>
 
#include "Animation.h"
#include "Sprite.h"
 
class Entity {
    public:
        static std::vector<Entity*>    EntityList;
 
    protected:
        Animation      Anim;
        SDL_Surface*    Surface;
 
    public:
        float           X;
        float           Y;
 
        int             Width;
        int             Height;
 
        int             AnimState;
 
    public:
        Entity();
        virtual ~Entity();
 
        virtual bool Load(char* File, int Width, int Height, int MaxFrames);
        virtual void Loop();
        virtual void Render(SDL_Surface* Screen);
        virtual void Cleanup();
};

Теперь откройте Entity.cpp и добавьте это:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

#include "Entity.h"
 
std::vector<Entity*> Entity::EntityList;
 
Entity::Entity() {
    Surface = NULL;
 
    X = Y = 0.0f;
 
    Width = Height = 0;
 
    AnimState = 0;
}
 
Entity::~Entity() {}
 
bool Entity::Load(char* File, int Width, int Height, int MaxFrames) {
    if((Surface = Sprite::Load(File)) == NULL) {
        return false;
    }
 
    Sprite::Transparent(Surface, 255, 0, 255);
 
    this->Width = Width;
    this->Height = Height;
 
    Anim.MaxFrames = MaxFrames;
 
    return true;
}
 
void Entity::Loop() {
    Anim.Animate();
}
 
void Entity::Render(SDL_Surface* Screen) {
    if(Surface == NULL || Screen == NULL) return;
 
    Sprite::Draw(Screen, Surface, X, Y, AnimState * Width, Anim.GetCurrentFrame() * Height, Width, Height);
}
 
void Entity::Cleanup() {
    if(Surface) {
        SDL_FreeSurface(Surface);
    }
 
    Surface = NULL;
}

Теперь поясню. В этом классе мы инкапсулируем 5 основных компонентов, о которых я упоминал в первой статье. Это позволит нам работать с сущностями в игре гораздо проще, чем смешивать их в кучу со всем остальным в классе App. Первое, что вы можете заметить, это статический вектор, который называется EntityList. Этот вектор будет содержать все наши сущности, они будут легко доступны через Entity::EntityList, потому что он объявлен статическим. Надо особо отметить: мы объявляем EntityList в Entity, поскольку это предотвратит циклические зависимости в будущем. То есть, например мы попытаемся получить карту, чтобы обработать сущности на ней, а также хотим получить сущности, чтобы обработать карту. Map объявляет Entity, Entity объявляет Map, это повлечет за собой проблемы во время компиляции.

Так что этот вектор содержит все наши сущности в игре. Обратите внимание, что каждый член вектора - указатель. Это потому, что в дальнейшем мы будем наследовать все последующие классы сущностей от класса Entity. Так, например, если мы собираемся сделать игру Megaman, мы бы создали класс Megaman и унаследовали бы его от класс Entity. И, благодаря полиморфизму, мы можем хранить объекты класса Megaman в EntityList. Собственно поэтому, мы заявили функции в классе, как virtual, а некоторые члены как protected.

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

Итак, у нас есть основная функция Loop, которая обрабатывает основные расчеты. Сейчас мы только занимаемся анимацией. Мы лишь меняем MaxFrames, а остальное оставляем по умолчанию. Далее, функция Render, в качестве параметра передается поверхность для отображения. Чтобы можно было рисовать не только сразу на экран, но и на любую другую поверхность по вашему выбору. Ну и наконец, функция Cleanup, которая освобождает память и все такое.

Как я уже говорил в начале, это лишь базовая структура класса Entity, она еще может не так много, но не волнуйтесь, в будущем сможет сделать все, что вы захотите. Итак, давайте заставим сущности работать. Откройте App.h и добавьте файл заголовка в начале, и объявить две сущности:

1
2
3
4
5
6
7

#include "Entity.h"
 
//...
 
private:
    Entity         Entity1;
    Entity         Entity2;

Давайте теперь загрузим в них изображения, в App::Init.cpp добавьте следующее:

1
2
3
4
5
6
7
8
9
10
11
12

if(Entity1.Load("./gfx/yoshi.bmp", 64, 64, 8) == false) {
    return false;
}
 
if(Entity2.Load("./gfx/yoshi.bmp", 64, 64, 8) == false) {
    return false;
}
 
Entity2.X = 100;
 
Entity::EntityList.push_back(&Entity1);
Entity::EntityList.push_back(&Entity2);

Я еще раз использую изображение Йоши и прошлой статьи.

Вспомните, что я говорил, про инкапсуляцию основных функции игры в классе Entity. Мы должны вызывать эти функции в соответствующих функциях App. Поэтому, откройте App::Loop и добавьте следующее:

1
2
3
4
5

for(int i = 0;i < Entity::EntityList.size();i++) {
    if(!Entity::EntityList[i]) continue;
 
    Entity::EntityList[i]->Loop();
}

Мы в обходим каждый элемент вектора и вызываем функцию Loop. Довольно просто. (И мы проверяем на NULL, чтобы не было ошибок). Теперь, давайте сделаем то же самое в App::Render:

1
2
3
4
5

for(int i = 0;i < Entity::EntityList.size();i++) {
    if(!Entity::EntityList[i]) continue;
 
    Entity::EntityList[i]->Render(Screen);
}

и еще раз то же самое в App::Cleanup:

1
2
3
4
5
6
7

for(int i = 0;i < Entity::EntityList.size();i++) {
    if(!Entity::EntityList[i]) continue;
 
    Entity::EntityList[i]->Cleanup();
}
 
Entity::EntityList.clear();

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

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

В последней статье мы создали прототип игры в крестики-нолики. Надеюсь, многие из вас смогли заставить его работать. Если нет, то не волнуйтесь, рано или поздно у вас все получится. В этой статье мы собираемся научиться делать анимацию с помощью SDL. Как и прежде, мы будем код предыдущих статей SDL, за исключением кода из Крестиков-ноликов. Я отменил почти все изменения, сделанные в той статье, оставил лишь Transparent функцию для класса Sprite.

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

Создайте два новых файла с названиями Animation.h и Animation.cpp. В будущем, наш Entity-класс будет наследовать этот класс, но пока что мы будем пользоваться им напрямую. Давайте сразу подключим файл в App.h:

1

#include "Animation.h"

Теперь откройте Animation.h и добавьте базовую структуру класса в файл:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#ifndef _ANIMATION_H_
#define _ANIMATION_H_
 
#include <SDL.h>
 
class Animation {
    private:
        int    CurrentFrame;
        int     FrameInc;
 
        int     FrameRate;
        long    OldTime;
 
    public:
        int    MaxFrames;
        bool    Oscillate;
 
    public:
        Animation();
        void Animate();
 
    public:
        void SetFrameRate(int Rate);
        void SetCurrentFrame(int Frame);
        int GetCurrentFrame();
};
 
#endif

Теперь откройте Animation.cpp и добавьте следующий код:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

#include "Animation.h"
 
Animation::Animation() {
    CurrentFrame    = 0;
    MaxFrames       = 0;
    FrameInc        = 1;
 
    FrameRate       = 100; //Milliseconds
    OldTime         = 0;
 
    Oscillate       = false;
}
 
void Animation::Animate() {
    if(OldTime + FrameRate > SDL_GetTicks()) {
        return;
    }
 
    OldTime = SDL_GetTicks();
 
    CurrentFrame += FrameInc;
 
    if(Oscillate) {
        if(FrameInc > 0) {
            if(CurrentFrame >= MaxFrames) {
                FrameInc = -FrameInc;
            }
        }else{
            if(CurrentFrame <= 0) {
                FrameInc = -FrameInc;
            }
        }
    }else{
        if(CurrentFrame >= MaxFrames) {
            CurrentFrame = 0;
        }
    }
}
 
void Animation::SetFrameRate(int Rate) {
    FrameRate = Rate;
}
 
void Animation::SetCurrentFrame(int Frame) {
    if(Frame < 0 || Frame >= MaxFrames) return;
 
    CurrentFrame = Frame;
}
 
int Animation::GetCurrentFrame() {
    return CurrentFrame;
}

Теперь объясню что же делает этот класс. Существует один основной элемент анимации, который мы должны обрабатывать - текущий кадр анимации. Возьмите изображение Йоши ниже (мы будем использовать его в этой статье). Вы увидите, у нас есть 8 кадров Йоши на одном изображении. Каждый кадр будет пронумерован 0, 1, 2 сверху вниз.

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

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

1

Sprite::Draw(Screen, Image, 0, 0, 0, Anim_Yoshi.GetCurrentFrame() * 64, 64, 64);

Так как наш Йоши размером 64 х 64 пикселей, столько мы и захватим для вывода, это же и является нашим кадром анимации. Посмотрите на иллюстрацию ниже.

Когда CurrentFrame увеличивается на 1, мы прыгаем вниз на 64 пикселя (высота кадра Yoshi), и рисуем этот кадр.

Другая часть этого класса нужна нам для того, чтобы определять, сколько кадров в анимации - MaxFrames. Наконец важно так же знать, сколько кадров в секунду, или, скорее, как быстро будет меняться анимированное изображение. Для этого мы используем вот этот кусок кода в функции Animate().

1
2
3

if(OldTime + FrameRate > SDL_GetTicks()) {
    return;
}

Если взять OldTime в миллисекундах плюс желаемую частоту кадров, мы можем сравнить это значение с количеством миллисекунл, которые SDL был запущен. Например, мы только что запустили нашу программу, SDL_GetTicks = 0, и OldTime = 0. Желаемая частота кадров будет 1 кадр в секунду. Итак FrameRate = 1000 (миллисекунд). 0 + 1000 больше 0? Да, так что мы не будем ничего делать и ждать. Но как только 0 + 1000 станет меньше, чем SDL_GetTicks, что означает, что 1 секунда прошла, мы увеличим номер кадра, а затем сбросим OldTime на текущее время, и начнем все сначала.

Следующий интересный момент это Oscillate и FrameInc. Я не хотел бы никого путать лишними переменными, но мне кажется, что это пригодится нам в будущем. В общем, когда Oscillate = true, в анимация будет увеличиваться номер кадра, а затем уменьшаться в обратном порядке. Если бы в анимации было 10 кадров, было бы как-то так:

0 1 2 3 4 5 6 7 8 9 8 7 6 5 4 3 2 1 2 ...

Видите, номер кадра идет до 9, а затем уменьшается обратно до 0, и так далее. Есть несколько интересных применений для этого, но мы этим займемся в других статьях. Так, как это работает? Взгляните на функцию Animate. Если Oscillate = false, то мы просто проверяем превысил ли номер текущего кадра максимальное количество кадров. Если да - сбрасываем на 0, а затем ниже, мы переходим к следующему кадру. В противположном же случае, у нас есть переменная FrameInc, которая принимает значения 1 или -1, в зависимости от того, увеличиваем или уменьшаем номер кадра. То есть, если FrameInc больше 0, мы увеличиваем номер кадра, иначе - уменьшаем. И если мы достигли первого или последнего кадра - меняем FrameInc на противоположный.

Теперь, когда мы обо всем позаботились, используем этот класс. Создайте новый объект типа Animation в App.h:

1

Animation      Anim_Yoshi;

Теперь, давайте установиv MaxFrames, добавьте в App::Init():

1
2

Sprite::Transparent(Test, 255, 0, 255);
Anim_Yoshi.MaxFrames = 8;

И теперь, чтобы анимация двигалась в App::Loop():

1

Anim_Yoshi.Animate();

И наконец, нарисуем на экране App::Render():

1
2
3
4
5
6

void App::Render() {
    SDL_FillRect(Screen, NULL, 0x000000);
    Sprite::Draw(Screen, Test, 290, 220, 0, Anim_Yoshi.GetCurrentFrame() * 64, 64, 64);
 
    SDL_Flip(Screen);
}

Теперь скомпилируйте и смотрить как работает наша анимация! SDL_FillRect заполняет указанную поверхность одним цветом, в данном случае черным, чтобы остатки анимации не мешались на экране.

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

Первое, что мы надо сделать - спланировать игру. Все мы знаем, что крестики-нолики имеют поле 3x3, где игроки ставят крестики или нолики. Итак, для этого нам будет нужно 3 изображения, одно для игрового поля, одно для X, и одно для О. Нам не нужно многокрестиков или ноликов, потому что мы можем отрисовывать их в программе сколько угодно раз. Наше игровое поле будет размером 600x600, а наши X и O будут 200x200 (1/3 площади).

[Это png изображения, для работы вам нужны bmp. Их можно взять в репозитории на гитхабе, ссылка в начале поста.]

Теперь у нас есть изображения, и нам нужен способ, чтобы загрузить их в нашу программу. Откройте App.h и внесите некоторые изменения. Удалите поверхность Test, и добавьте три новых поверхности.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

#ifndef _APP_H_
#define _APP_H_
 
#include <SDL.h>
 
#include "Event.h"
#include "Sprite.h"
 
class App : public Event {
    private:
        bool            Running;
        SDL_Surface*    Screen;
 
        SDL_Surface*    G;
        SDL_Surface*    X;
        SDL_Surface*    O;
 
    public:
        App();
        int Execute();
 
        bool Init();
        void Event(SDL_Event* Evt);
        void Loop();
        void Render();
        void Cleanup();
        void Exit();
};
 
#endif

Далее, откройте App.cpp и проделайте то же самое, удалите Test и добавьте три новых поверхности. В конструкторе:

1
2
3
4
5
6
7
8

App::App() {
    G = NULL;
    X = NULL;
    O = NULL;
    Screen = NULL;
 
    Running = true;
}

и не забудьте об освобождении ресурсов:

1
2
3
4
5
6
7

void App::Cleanup() {
    SDL_FreeSurface(G);
    SDL_FreeSurface(X);
    SDL_FreeSurface(O);
    SDL_FreeSurface(Screen);
    SDL_Quit();
}

Теперь у нас есть три готовые поверхности, давайте загрузим туда изображения. Найдите App::Init(), и внесите изменения: избавимся от поверхности Test (опять), и загрузим три новых изображения. Обратите внимание, что мы изменили размер окна до размеров игрового поля - 600х600.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

bool App::Init() {
    if(SDL_Init(SDL_INIT_EVERYTHING) < 0) {
        return false;
    }
 
    if((Screen = SDL_SetVideoMode(600, 600, 32, SDL_HWSURFACE | SDL_DOUBLEBUF)) == NULL) {
        return false;
    }
 
    if((G = Sprite::Load("./gfx/grid.bmp")) == NULL) {
    return false;
    }
 
    if((X = Sprite::Load("./gfx/x.bmp")) == NULL) {
    return false;
    }
 
    if((O = Sprite::Load("./gfx/o.bmp")) == NULL) {
    return false;
    }
 
    return true;
}

Как вы могли заметить, теперь графические файлы находятся в папке gfx. Со временем, когда игра растет, становится очень удобно держать все изображения в одной папке. Давайте теперь нарисуем игровое поле на экране. Откройте App::Render.cpp и добавьте следующее:

1
2
3
4
5

void App::Render() {
    Sprite::Draw(Screen, G, 0, 0);
 
    SDL_Flip(Screen);
}

Скомпилируйте программу, и если все хорошо - вы должны увидеть игровое поле. Помните, что есть 5 основных моментов использования поверхностей: объявить ее, установите ее в NULL, загрузите изображение, нарисуйте поверхность, а затем освободите ее. Я советую вам, запомнить эти 5 шагов сейчас, потому что позже, если вы пропустите один из них, вы можете столкнуться с проблемами. Например, не установленная в NULL поверхность, может привести к непредсказуемому поведению или, не освобожденная поверхность, может привести к утечке памяти.

Вы наверняка удивляетесь, почему наши X и O на розовом фоне. Для этого, конечно же, есть причина. Мы собираемся реализовать прозрачность у этих поверхностей. По существу, везде, где сейчас розовый цвет, поверхность будет прозрачной. В SDL есть простая функция для этого SDL_SetColorKey. Давайте добавим ее в Sprite.h:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#ifndef _SPRITE_H_
#define _SPRITE_H_
 
#include <SDL.h>
 
class Sprite {
    public:
        Sprite();
 
        static SDL_Surface* Load(const char* File);
        static bool Draw(SDL_Surface* Dest, SDL_Surface* Src, int X, int Y);
        static bool Draw(SDL_Surface* Dest, SDL_Surface* Src, int X, int Y, int X2, int Y2, int W, int H);
        static bool Transparent(SDL_Surface* Surface, int R, int G, int B);
};
 
#endif

Теперь, в Sprite.cpp добавим ее реализацию:

1
2
3
4
5
6
7
8
9

bool Sprite::Transparent(SDL_Surface* Surface, int R, int G, int B) {
    if(Surface == NULL) {
        return false;
    }
 
    SDL_SetColorKey(Surface, SDL_SRCCOLORKEY | SDL_RLEACCEL, SDL_MapRGB(Surface->format, R, G, B));
 
    return true;
}

Обратите внимание на 3 дополнительных параметра, которые передаются помимо поверхности. Эти параметры обозначают цвет, в системе RGB, который мы хотим сделать прозрачным, это не обязательно должен быть розовый. Например, если бы мы хотели, чтобы прозрачным был красный, то передали бы в функцию: 255, 0, 0.

Функция Transparent сначала проверяет, есть ли у нас действительная поверхность. Если да, то установливает цветовой ключ[aka хромакей] (прозрачность). Первым аргументом идет поверхность к которой применяется хромакей, вторым параметром идут различные флаги, а третьим цвет, который будет прозрачным. Флаги, которые мы передаем вполне обычные, первый говорит SDL применять хромакей для переданной поверхности, а второй говорит SDL попытаться использовать RLE ускорение (чтобы сделать отрисовку быстрее). Третий аргумент выглядит чуть более сложным, мы используем SDL_MapRGB для создания цвета. SDL_MapRGB принимает параметром поверхность, и желаемый цвет (R, G, B), и подобрать наиболее близкий к нему для этой поверхности. Не все поверхности имеют одинаковую цветовую палитру. Вспомните старые времена Денди, там можно было использовать всего несколько цветов. Та же идея здесь, SDL_MapRGB берет цвет и сопоставляет его с ближайшим цветом в палитре этой поверхности.

Давайте теперь применим эту новую функцию к нашим поверхностям, откройте App::Init и внесите следующие изменения:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

bool App::Init() {
    if(SDL_Init(SDL_INIT_EVERYTHING) < 0) {
        return false;
    }
 
    if((Screen = SDL_SetVideoMode(600, 600, 32, SDL_HWSURFACE | SDL_DOUBLEBUF)) == NULL) {
        return false;
    }
 
    if((G = Sprite::Load("./gfx/grid.bmp")) == NULL) {
    return false;
    }
 
    if((X = Sprite::Load("./gfx/x.bmp")) == NULL) {
    return false;
    }
 
    if((O = Sprite::Load("./gfx/o.bmp")) == NULL) {
    return false;
    }
 
    Sprite::Transparent(X, 255, 0, 255);
    Sprite::Transparent(O, 255, 0, 255);
 
    return true;
}

Теперь все, что касается поверхностей, должно быть готово. Следующее, что нам нужно сделать, это выяснить как рисовать эти X и O. Мы не можем просто рисовать их везде по полю, потому что они не всегда будут в одинаковых местах. И вот что мы сделаем, мы создадим массив из 9 контейнеров, значения в этом массиве будет говорить о том, какая фигура стоит в каждой ячейке клетки, а индекс - номер ячейки. То есть, ячейка с индексом 0 будет в верхнем левом углу, с индексом 1 будет вверху посередине, 2 в правом верхнем углу, 3 в середине слева, и так далее.

Каждая ячейка может иметь три значения: Empty, X, и О. Чтобы все выглядело немного аккуратнее, чем просто 0, 1, 2, в массиве, мы будем использовать перечисление (enum). Обозначим GRID_TYPE_NONE = 0, GRID_TYPE_X = 1, и GRID_TYPE_O = 2.

Теперь добавим массив и перечисление в App.h:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

#ifndef _APP_H_
#define _APP_H_
 
#include <SDL.h>
 
#include "Event.h"
#include "Sprite.h"
 
enum {
    GRID_TYPE_NONE = 0,
    GRID_TYPE_X,
    GRID_TYPE_O
};
 
class App : public Event {
    private:
        bool            Running;
        SDL_Surface*    Screen;
 
        SDL_Surface*    G;
        SDL_Surface*    X;
        SDL_Surface*    O;
 
        int             Grid[9];
 
    public:
        App();
        int Execute();
 
        bool Init();
        void Event(SDL_Event* Evt);
        void Loop();
        void Render();
        void Cleanup();
        void Exit();
};
 
#endif

С этого момента, я буду давать только код требуемых функций, а не код из файла. Надеюсь, что вы уже запомнили где находятся основные функции, и это не станет проблемой. Нам нужно добавить функцию сброса игрового поля. Она установит все значения массива в GRID_TYPE_NONE, и это будет означать, что все клетки поля пусты. Добавим так же вызов этой функции в инициализацию:

В App.h:

1
2

public:
    void Reset();

В App.cpp:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

void App::Reset() {
    for(int i = 0;i < 9;i++) {
        Grid[i] = GRID_TYPE_NONE;
    }
}
 
bool App::Init() {
    if(SDL_Init(SDL_INIT_EVERYTHING) < 0) {
        return false;
    }
 
    if((Screen = SDL_SetVideoMode(600, 600, 32, SDL_HWSURFACE | SDL_DOUBLEBUF)) == NULL) {
        return false;
    }
 
    if((G = Sprite::Load("./gfx/grid.bmp")) == NULL) {
    return false;
    }
 
    if((X = Sprite::Load("./gfx/x.bmp")) == NULL) {
    return false;
    }
 
    if((O = Sprite::Load("./gfx/o.bmp")) == NULL) {
    return false;
    }
 
    Sprite::Transparent(X, 255, 0, 255);
    Sprite::Transparent(O, 255, 0, 255);
 
    Reset();
 
    return true;
}

Следующее, что мы должны сделать, это функция размещения X и O на экране. Давайте ее создадим. Откройте опять App.h и добавьте функцию ниже Reset:

1

void SetCell(int ID, int Type);

И в App.cpp:

1
2
3
4
5
6

void App::SetCell(int ID, int Type) {
    if(ID < 0 || ID >= 9) return;
    if(Type < 0 || Type > GRID_TYPE_O) return;
 
    Grid[ID] = Type;
}

Эта функция принимает два аргумента: во-первых, id изменяемой ячейки, а во-вторых тип, в который мы ее устанавливаем. У нас есть два условия, во-первых, убедимся, что мы не выходим за границы массива (иначе наша программа бы упала), а во-вторых, убедимся, что мы задаем правильный тип. Теперь давайте сделаем так, чтобы X и O отрисовывались на экране. Добавим следующий код в App::Render:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

void App::Render() {
    Sprite::Draw(Screen, G, 0, 0);
 
    for(int i = 0;i < 9;i++) {
        int cX = (i % 3) * 200;
        int cY = (i / 3) * 200;
 
        if(Grid[i] == GRID_TYPE_X) {
            Sprite::Draw(Screen, X, cX, cY);
        }else
        if(Grid[i] == GRID_TYPE_O) {
            Sprite::Draw(Screen, O, cX, cY);
        }
    }
 
    SDL_Flip(Screen);
}

Это немного сложнее, чем то, что мы делали до сих пор. Во-первых, мы проходим по каждой ячейке поля, переводим ID клетки в X и Y координаты. Чтобы найти X, мы берем остаток от деления на 3. Это даст нам 0, когда i = 0, 1, когда i = 1, 2, когда i = 2, 0, когда i 3, и так далее. Умножим полученное число на 200, потому что каждая клетка размером 200x200 пикселей, и получаем координату X. Чтобы найти Y, мы делим на 3 без остатка, это дает 0, когда i = [0, 1, 2], 1, когда i = [3, 4, 5], и так далее. Затем опять умножаем на 200. Я настоятельно советую вам разобраться, как это работает, потому что методы такого рода используются для tile-based игр.

Наконец, нам нужно обрабатывать пользовательские действия. Для этого мы будем отлавливать события мышки. Когда пользователь нажимает на ячейку будем ставить в нее X или O. Переопределим один из методов Event для этого. Откройте App.h и добавьте функцию и переменную, про нее я скажу чуть позже:

1
2
3

int CurrentPlayer;
 
void OnLButtonDown(int mX, int mY);

И в App.cpp:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

void App::OnLButtonDown(int mX, int mY) {
    int ID = mX / 200;
    ID = ID + ((mY / 200) * 3);
 
    if(Grid[ID] != GRID_TYPE_NONE) {
        return;
    }
 
    if(CurrentPlayer == 0) {
        SetCell(ID, GRID_TYPE_X);
        CurrentPlayer = 1;
    }else{
        SetCell(ID, GRID_TYPE_O);
        CurrentPlayer = 0;
    }
}

Сначала мы делаем обратное преобразование, из координат в ID. Затем проверяем, что клетка еще не занята, иначе выходим из функции. Потом проверяем, чей сейчас ход, ставим соответствующую фигуру и передаем ход другому игроку. Как раз CurrentPlayer и говорит нам о том, чей сейчас ход. Кстати, ее надо инициализировать в конструкторе в App.cpp:

1
2
3
4
5
6
7
8
9
10
11

App::App() {
    CurrentPlayer = 0;
 
    G = NULL;
    X = NULL;
    O = NULL;
 
    Screen = NULL;
 
    Running = true;
}

Скомпилируйте программу и вы должны получить почти полностью работающую версию крестиков-ноликов. Поздравляем!

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

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

Говоря об основах разработки игр нельзя не упомянуть о том, что называется событиями (Events). Все видеоигры, от Pong до очень сложных игр для ПК и консоли, используют события для взаимодействия с игроком. Эти события могут поступать от клавиатуры, мыши, джойстика, геймпада, и так далее, даже из операционной системы. Важно понять, как работают события, если мы хотим позволить пользователю взаимодействовать с игрой. Мы уже использовали события, но только для закрытия нашего окна, теперь мы посмотрим, как получать события от пользователя.

Если вы еще не догадались, каждая статья построена на основе предыдущих, так что будем использовать код из предыдущей статьи. Чтобы отслеживать все эти события и использовать их в наших функциях, давайте создадим новый класс. Создайте два файла с названиями: Event.h и Event.cpp. Эти два файла будет обрабатывать наши события, и вызвать соответствующую функцию. Класс App будет наследовать этот класс, поэтому, когда нам нужно будет поймать событие мы просто переопределим функцию.

Откройте Event.h и добавьте следующий код:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

#ifndef _EVENT_H_
#define _EVENT_H_
 
#include <SDL.h>
 
class Event {
    public:
        Event();
        virtual ~Event();
        virtual void Handle(SDL_Event* Event);
        virtual void OnInputFocus();
        virtual void OnInputBlur();
        virtual void OnKeyDown(SDLKey sym, SDLMod mod, Uint16 unicode);
        virtual void OnKeyUp(SDLKey sym, SDLMod mod, Uint16 unicode);
        virtual void OnMouseFocus();
        virtual void OnMouseBlur();
        virtual void OnMouseMove(int mX, int mY, int relX, int relY, bool Left,bool Right,bool Middle);
        virtual void OnMouseWheel(bool Up, bool Down);
        virtual void OnLButtonDown(int mX, int mY);
        virtual void OnLButtonUp(int mX, int mY);
        virtual void OnRButtonDown(int mX, int mY);
        virtual void OnRButtonUp(int mX, int mY);
        virtual void OnMButtonDown(int mX, int mY);
        virtual void OnMButtonUp(int mX, int mY);
        virtual void OnJoyAxis(Uint8 which, Uint8 axis, Sint16 value);
        virtual void OnJoyButtonDown(Uint8 which, Uint8 button);
        virtual void OnJoyButtonUp(Uint8 which, Uint8 button);
        virtual void OnJoyHat(Uint8 which, Uint8 hat, Uint8 value);
        virtual void OnJoyBall(Uint8 which, Uint8 ball, Sint16 xrel, Sint16 yrel);
        virtual void OnMinimize();
        virtual void OnRestore();
        virtual void OnResize(int w,int h);
        virtual void OnExpose();
        virtual void Exit();
        virtual void OnUser(Uint8 type, int code, void* data1, void* data2);
};
 
#endif

Немаленький класс, да? Так, а теперь откройте Event.cpp и добавьте следующий код:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

#include "Event.h"
 
Event::Event() {}
Event::~Event() {}
 
void Event::Handle(SDL_Event* Event) {
    switch(Event->type) {
        case SDL_ACTIVEEVENT: {
            switch(Event->active.state) {
                case SDL_APPMOUSEFOCUS: {
                    if ( Event->active.gain )
			OnMouseFocus();
                    else
			OnMouseBlur();
                    break;
                }
                case SDL_APPINPUTFOCUS: {
                    if ( Event->active.gain )
			OnInputFocus();
                    else
			OnInputBlur();
                    break;
                }
                case SDL_APPACTIVE:    {
                    if ( Event->active.gain )
			OnRestore();
                    else
			OnMinimize();
                    break;
                }
            }
            break;
        }
 
        case SDL_KEYDOWN: {
            OnKeyDown(Event->key.keysym.sym,Event->key.keysym.mod,Event->key.keysym.unicode);
            break;
        }
 
        case SDL_KEYUP: {
            OnKeyUp(Event->key.keysym.sym,Event->key.keysym.mod,Event->key.keysym.unicode);
            break;
        }
 
        case SDL_MOUSEMOTION: {
            OnMouseMove(Event->motion.x,Event->motion.y,Event->motion.xrel,Event->motion.yrel,(Event->motion.state&SDL_BUTTON(SDL_BUTTON_LEFT))!=0,(Event->motion.state&SDL_BUTTON(SDL_BUTTON_RIGHT))!=0,(Event->motion.state&SDL_BUTTON(SDL_BUTTON_MIDDLE))!=0);
            break;
        }
 
        case SDL_MOUSEBUTTONDOWN: {
            switch(Event->button.button) {
                case SDL_BUTTON_LEFT: {
                    OnLButtonDown(Event->button.x,Event->button.y);
                    break;
                }
                case SDL_BUTTON_RIGHT: {
                    OnRButtonDown(Event->button.x,Event->button.y);
                    break;
                }
                case SDL_BUTTON_MIDDLE: {
                    OnMButtonDown(Event->button.x,Event->button.y);
                    break;
                }
            }
            break;
        }
 
        case SDL_MOUSEBUTTONUP:    {
            switch(Event->button.button) {
                case SDL_BUTTON_LEFT: {
                    OnLButtonUp(Event->button.x,Event->button.y);
                    break;
                }
                case SDL_BUTTON_RIGHT: {
                    OnRButtonUp(Event->button.x,Event->button.y);
                    break;
                }
                case SDL_BUTTON_MIDDLE: {
                    OnMButtonUp(Event->button.x,Event->button.y);
                    break;
                }
            }
            break;
        }
 
        case SDL_JOYAXISMOTION: {
            OnJoyAxis(Event->jaxis.which,Event->jaxis.axis,Event->jaxis.value);
            break;
        }
 
        case SDL_JOYBALLMOTION: {
            OnJoyBall(Event->jball.which,Event->jball.ball,Event->jball.xrel,Event->jball.yrel);
            break;
        }
 
        case SDL_JOYHATMOTION: {
            OnJoyHat(Event->jhat.which,Event->jhat.hat,Event->jhat.value);
            break;
        }
        case SDL_JOYBUTTONDOWN: {
            OnJoyButtonDown(Event->jbutton.which,Event->jbutton.button);
            break;
        }
 
        case SDL_JOYBUTTONUP: {
            OnJoyButtonUp(Event->jbutton.which,Event->jbutton.button);
            break;
        }
 
        case SDL_QUIT: {
            Exit();
            break;
        }
 
        case SDL_SYSWMEVENT: {
            //Ignore
            break;
        }
 
        case SDL_VIDEORESIZE: {
            OnResize(Event->resize.w,Event->resize.h);
            break;
        }
 
        case SDL_VIDEOEXPOSE: {
            OnExpose();
            break;
        }
 
        default: {
            OnUser(Event->user.type,Event->user.code,Event->user.data1,Event->user.data2);
            break;
        }
    }
}
 
void Event::OnInputFocus() {}
void Event::OnInputBlur() {}
void Event::OnKeyDown(SDLKey sym, SDLMod mod, Uint16 unicode) {}
void Event::OnKeyUp(SDLKey sym, SDLMod mod, Uint16 unicode) {}
void Event::OnMouseFocus() {}
void Event::OnMouseBlur() {}
void Event::OnMouseMove(int mX, int mY, int relX, int relY, bool Left,bool Right,bool Middle) {}
void Event::OnMouseWheel(bool Up, bool Down) {}
void Event::OnLButtonDown(int mX, int mY) {}
void Event::OnLButtonUp(int mX, int mY) {}
void Event::OnRButtonDown(int mX, int mY) {}
void Event::OnRButtonUp(int mX, int mY) {}
void Event::OnMButtonDown(int mX, int mY) {}
void Event::OnMButtonUp(int mX, int mY) {}
void Event::OnJoyAxis(Uint8 which,Uint8 axis,Sint16 value) {}
void Event::OnJoyButtonDown(Uint8 which,Uint8 button) {}
void Event::OnJoyButtonUp(Uint8 which,Uint8 button) {}
void Event::OnJoyHat(Uint8 which,Uint8 hat,Uint8 value) {}
void Event::OnJoyBall(Uint8 which,Uint8 ball,Sint16 xrel,Sint16 yrel) {}
void Event::OnMinimize() {}
void Event::OnRestore() {}
void Event::OnResize(int w,int h) {}
void Event::OnExpose() {}
void Event::Exit() {}
void Event::OnUser(Uint8 type, int code, void* data1, void* data2) {}

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

Теперь, когда с этим разобрались, перейдет к App.h и подключим наш новый класс:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#ifndef _APP_H_
#define _APP_H_
 
#include <SDL.h>
 
#include "Event.h"
#include "Sprite.h"
 
class App : public Event {
    private:
        bool            Running;
        SDL_Surface*    Screen;
        SDL_Surface*    Test;
 
    public:
        App();
        int Execute();
 
        bool Init();
        void Event(SDL_Event* Evt);
        void Loop();
        void Render();
        void Cleanup();
};
 
#endif

Все должно хорошо скомпилироваться. Теперь надо связать поступающие события с нашим классом. Найдите App::Event() и измените функцию вот так:

1
2
3

void App::Event(SDL_Event* Evt) {
    Event::Handle(Evt);
}

Мы передаем событие в наш класса, теперь он будет заботиться о правильном вызовов функций. Теперь, когда мы хотим использовать событие, мы должны переопределить функцию. Так как мы избавились от проверки события SDL_Quit, давайте использовать вместо этого метод класса. Откройте App.h, и добавьте следующие функции:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#ifndef _APP_H_
#define _APP_H_
 
#include <SDL.h>
 
#include "Event.h"
#include "Sprite.h"
 
class App : public Event {
    private:
        bool            Running;
        SDL_Surface*    Screen;
        SDL_Surface*    Test;
 
    public:
        App();
        int Execute();
 
        bool Init();
        void Event(SDL_Event* Evt);
        void Loop();
        void Render();
        void Cleanup();
        void Exit();
};
 
#endif

Функция Exit() будет обрабатывать событие SDL_Quit. У нас есть прототип, позволяющий определить, что он делает, теперь добавим реализацию. Откройте App.cpp и добавьте следующее:

1
2
3

void App::Exit() {
    Running = false;
}

Перекомпилируйте и попробуйте запустить. Программа должна закрываться по крестику как и раньше. Я рекомендую вам ознакомиться с несколькими другими событиями. В дальнейшем мы будем использовать некоторые из них в нашей игре.

Перейти на более чем на следующем уроке, чтобы взглянуть на создание нашей первой игре, крестики-нолики./strong

Используя первую статью, как базу, углубимся в мир поверхностей SDL. Я пытался донести до вас мысль, что SDL поверхности - это в основном изображения, хранящиеся в памяти. Представьте что, у нас есть пустая поверхность размером 320x240 пикселей. Если добавить к ней систему SDL координат, то получится что-то вроде этого:

Эта система координат отличается, от обычной. Обратите внимание, что координата Y увеличивается вниз, а координата X увеличивается вправо. Это важно понимать, чтобы правильно рисовать изображения на экране.

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

1
2
3
4
5

SDL_Surface* TmpSurface;
 
if((TmpSurface = SDL_LoadBMP("mypicture.bmp")) == NULL) {
    //Error!
}

Все довольно просто, SDL_LoadBMP принимает один аргумент, имя файла, который вы хотите загрузить, и возвращает поверхность. Если функция возвращает NULL, то либо файл не найден, либо поврежден или произошла какая-либо другая ошибка. К сожалению, чтобы все работало быстро, одного этого метода недостаточно. Часто изображение будет загружено в другом формате. И, когда мы будем отображать изображение на экране, мы можем столкнуться с потерей производительности, выпадением цветов изображения, и т.п. Но, к счастью SDL предлагает решение этой проблемы - функцию SDL_DisplayFormat. Она принимает уже загруженную поверхность, и возвращает новую, уже использующую тот же формат, что и дисплей.

Давайте этот процесс завернем класс. Возьмем код из предыдущей статьи за основу и добавим два новых файла: Sprite.h и Sprite.cpp. Откройте Sprite.h и добавьте следующее:

1
2
3
4
5
6
7
8
9
10
11
12
13

#ifndef _SPRITE_H_
#define _SPRITE_H_
 
#include <SDL.h>
 
class Sprite {
    public:
        Sprite();
    public:
        static SDL_Surface* Load(const char* File);
};
 
#endif

Мы создали простую статическую функцию Load, которая будет загружать файл в поверхность. Теперь откроем Sprite.cpp:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#include "Sprite.h"
 
Sprite::Sprite() {}
 
SDL_Surface* Sprite::Load(const char* File) {
    SDL_Surface* Temp = NULL;
    SDL_Surface* Result = NULL;
 
    if((Temp = SDL_LoadBMP(File)) == NULL) {
        return NULL;
    }
 
    Result = SDL_DisplayFormat(Temp);
    SDL_FreeSurface(Temp);
 
    return Result;
}

Надо отменить несколько важных вещей. Во-первых, всегда помните, что когда вы создаете указатель, установите его в значение NULL или 0. Вы можете столкнуться с проблемами, если вы это не сделаете. Во-вторых, обратите внимание, что SDL_DisplayFormat возвращает новую поверхность, а не перезаписывает оригинальную. Это важно помнить, потому что, поскольку он создает новую поверхность, мы должны освободить старую. В противном случае, у она так и будет занимать память.

Теперь у нас есть способ загрузки поверхностей в памяти, теперь же нужен способ отображать их поверх других поверхностей. Как и в случае с загрузкой изображений, SDL предлагает функцию для блиттинга: SDL_BlitSurface. Она не такая простая как SDL_LoadBMP, но все же достаточно простая. Откроем Sprite.h и добавим следующие прототипы функций:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#ifndef _SPRITE_H_
#define _SPRITE_H_
 
#include <SDL.h>
 
class Sprite {
    public:
        Sprite();
 
        static SDL_Surface* Load(const char* File);
        static bool Draw(SDL_Surface* Dest, SDL_Surface* Src, int X, int Y);
};
 
#endif

Теперь откройте Sprite.cpp, и добавьте следующее:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#include "Sprite.h"
 
Sprite::Sprite() {
}
 
SDL_Surface* Sprite::Load(const char* File) {
    SDL_Surface* Temp = NULL;
    SDL_Surface* Result = NULL;
 
    if((Temp = SDL_LoadBMP(File)) == NULL) {
        return NULL;
    }
 
    Result = SDL_DisplayFormat(Temp);
    SDL_FreeSurface(Temp);
 
    return Result;
}
 
bool Sprite::Draw(SDL_Surface* Dest, SDL_Surface* Src, int X, int Y) {
    if(Dest == NULL || Src == NULL) {
        return false;
    }
 
    SDL_Rect Area;
    Area.x = X;
    Area.y = Y;
 
    SDL_BlitSurface(Src, NULL, Dest, &Area);
 
    return true;
}

Прежде всего, посмотрим на аргументы, которые передаются функции Draw. У нас есть две поверхности, и две переменные типа int. Первая поверхность Dest - на ней мы будем рисовавать, вторая поверхность Src - из нее будут браться данные для отображения. Можно сказать, что мы "наклеиваем" (помните аналогию со стикерами?) Src на Dest. X, Y - это координаты на поверхности Dest где будет находиться верхний левый угол изображения из Src.

Теперь к содержимому функции. Сначала мы проверяем, что у нас есть действительная поверхность, иначе возвращаем false. Далее, определяем SDL_Rect. Это SDL структура, которая состоит из четырех элементов: X, Y, W, H. Как вы, возможно, догадались, это задает размеры прямоугольника. В нашем случае, мы заботимся только о том, где мы рисуем, а не сколько. Поэтому, мы назначаем X, Y координаты на поверхности Dest. Если вам интересно, что означает NULL среди параметров функции SDL_BlitSurface, то это еще один параметр SDL_Rect. К нему мы вернемся позже. Наконец, мы вызваем функцию переноса изображения, и возвращаем true.

Теперь, чтобы убедиться, что все это работает, давайте создадим тестовую поверхность. Откройте App.h, и создайте новую поверхность, и подключите недавно созданный Sprite.h:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#ifndef _APP_H_
#define _APP_H_
 
#include <SDL.h>
#include "Sprite.h"
 
class App {
    private:
        bool            Running;
        SDL_Surface*    Screen;
        SDL_Surface*    Test;
 
    public:
        App();
        int Execute();
 
    public:
        bool Init();
        void Event(SDL_Event* Event);
        void Loop();
        void Render();
        void Cleanup();
};
 
#endif

Не забудьте инициализировать поверхность значением NULL в конструкторе:

1
2
3
4
5

App::App() {
    Test = NULL;
    Screen = NULL;
    Running = true;
}

И так же не забудьте "прибраться" за собой:

1
2
3
4
5

void App::Cleanup() {
    SDL_FreeSurface(Test);
    SDL_FreeSurface(Screen);
    SDL_Quit();
}

Давайте теперь загрузим изображение. Перейдите к функции App::Init(), добавьте код:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

 
bool App::Init() {
    if(SDL_Init(SDL_INIT_EVERYTHING) < 0) {
        return false;
    }
 
    if((Screen = SDL_SetVideoMode(640, 480, 32, SDL_HWSURFACE | SDL_DOUBLEBUF)) == NULL) {
        return false;
    }
 
    if((Test = Sprite::Load("image.bmp")) == NULL) {
        return false;
    }
 
    return true;
}

Не забудьте заменить "image.bmp" реальным изображением, которое у вас есть. Если нету - откройте MSPaint, что-нибудь нарисуйте, и сохраните в той же папке, где будет ваш исполняемый файл. Теперь у нас есть загруженное изображение, которое можно нарисовать. Найдите App::Render и добавьте следующее:

1
2
3
4
5

void App::Render() {
    Sprite::Draw(Screen, Test, 0, 0);
 
    SDL_Flip(Screen);
}

Обратите внимание на новую функцию SDL_Flip. Это просто обновление буфера и вывод Screen на экран. Это называется двойной буферизацией. Это процесс рисования всего в памяти, и, потом вывод на экран. Если этого не делать, получилось бы мерцающее изображение. Помните флаг SDL_DOUBLEBUF? Это он и включает двойную буферизацию.

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

Теперь давайте продвинемся немного дальше. Хотя это круто уметь рисовать изображение на экране, часто нам нужна только его часть. Возьмем, к примеру, набор тайлов (tileset):

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#ifndef _SPRITE_H_
#define _SPRITE_H_
 
#include <SDL.h>
 
class Sprite {
    public:
        Sprite();
 
        static SDL_Surface* Load(const char* File);
        static bool Draw(SDL_Surface* Dest, SDL_Surface* Src, int X, int Y);
        static bool Draw(SDL_Surface* Dest, SDL_Surface* Src, int X, int Y, int X2, int Y2, int W, int H);
};
 
#endif

Теперь в Sprite.cpp (Внимание, мы добавляем еще одну функцию Draw, мы не заменяем первую):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

bool Sprite::Draw(SDL_Surface* Dest, SDL_Surface* Src, int X, int Y, int X2, int Y2, int W, int H) {
    if(Dest == NULL || Src == NULL) {
        return false;
    }
 
    SDL_Rect DestArea;
 
    DestArea.x = X;
    DestArea.y = Y;
 
    SDL_Rect SrcArea;
 
    SrcArea.x = X2;
    SrcArea.y = Y2;
    SrcArea.w = W;
    SrcArea.h = H;
 
    SDL_BlitSurface(Src, &SrcArea, Dest, &DestArea);
 
    return true;
}

Обратите внимание, что это в основном точно такая же функция, как и первыая, за исключением того, мы добавили еще один SDL_Rect. Этот SDL_Rect прямоугольник определяет, какие пикселы из исходного изображения скопировать в итоговое. Если, например, указаны параметры 0, 0, 50, 50, то отрисовано было бы лишь левая верхняя часть поверхности (квадрат размером 50х50).

Давайте проверим как это работает, найдите App::Render(), и добавьте следующее:

1
2
3
4
5
6

void App::Render() {
    Sprite::Draw(Screen, Test, 0, 0);
    Sprite::Draw(Screen, Test, 70, 110, 90, 90, 50, 50);
 
    SDL_Flip(Screen);
}

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

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

В статьях я буду использовать Code::Blocks в качестве IDE и gcc с mingw для компиляции. [Я лично изначально использовал gcc с cygwin, но такой набор потребует включения cygwin1.dll в дистрибутив, что может накладывать лицензионные ограничения. Поэтому позже я установил mingw компилятор из тех же репозиториев cygwin.] Если вы хотите использовать другую IDE и/или компилятор, вы, конечно, можете это сделать, если достаточно уверены, что сможете включить все библиотеки в линковку. Скачать же Code::Blocks можно на официальном сайте http://www.codeblocks.org (скачать версию, включающую MinGW). Рекомендуется использовать стабильную версию, если вы не хотите тратить время на ночные сборки.

Эти статьи в значительной степени сосредоточены вокруг SDL (Simple DirectMedia Layer), 2D кросс-платформенной графической библиотеки. Эта библиотека позволит отрисовывать графику, и делать разные классные вещи, которые потом и помогут нам сделать игру. Вам также надо будет загрузить библиотеку с сайта http://www.libsdl.org. Вам нужен tar-файл в разделе "Development Libraries, Win32" и zip-файл в разделе "Runtime Libraries, Win32". Если вы используете Visual Studio - выберите соответствующий файл вместо MinGW версии. После скачивания вы можете скопировать .dll файлы в папку Windows/system32, таким образом любое SDL приложение сможет его использовать. [Я не стал этого делать, достаточно чтобы SDL.dll и другие необходимые dll файлы находились в той же папке, что и исполняемый файл].

Начните новый проект (Blank project) в Code::Blocks, назовите по желанию и сохраните в удобное для вас место. Откройте tar-файл (который вы скачали из раздела "Development Libraries"), из него нам нужны папки include и lib, распакуйте их в папку вашего проекта. Вернемся обратно в Code::Blocks, кликните правой кнопкой на проект, слева в списке проектов, и в появившемся меню выберите "Build Options". Слева в дереве скорее всего будет имя вашего проекта и два пункта: Debug и Release. Выберите корень дерева, таким образом мы установим настройки сразу для всего проекта. Нас интересуют две вкладки: Search Directories и Linker Settings. В Search Directories по умолчанию выбрана вкладка Compiler, снизу нажмите Add и добавьте 2 папки: include и include/SDL. Этим мы облегчили подключение заголовочных файлов. Теперь во вкладке Linker Settings также нажимаем Add и добавляем файлы: libSDLmain.a и libSDL.dll.a (!Именно в таком порядке!). Этим мы подключили библиотеки SDL в наш проект. Нажимайте ОК и настройка проекта на этом закончена. [Если в будущем у вас возникнут проблемы с '_WinMain@16', то в Linker Settings, справа от библиотек в окне Other linker options допишите -lmingw32. Если возникнет проблема с libgcc_s_dw2-1.dll, допишите там же -static.]

Давайте, наконец, создадим два файла, назовем их App.h и App.cpp, это будет ядром нашей программы. Откройте App.h и добавьте туда следующий код:

1
2
3
4
5
6
7
8
9
10
11

#ifndef _APP_H_
#define _APP_H_
 
#include <SDL.h>
 
class App {
    public:
        App();
        int Execute();
};
#endif

Теперь в файл App.cpp добавим вот этот код:

1
2
3
4
5
6
7
8
9
10
11
12
13

#include "App.h"
 
App::App() {}
 
int App::Execute() {
    return 0;
}
 
int main(int argc, char* argv[]) {
    App App;
 
    return App.Execute();
}

Класс App - это основа всей нашей программы. Давайте сделаем шаг в сторону и я расскажу как игры обычно устроены. Большинство игр состоят из 5 функций, контролирующих игровой процесс. Обычно это:

Initialize
Функция обрабатывает загрузку всех данных, текстур, карт, NPC, чего угодно.

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

Loop
Функция обрабатывает обновление данных, например движение NPC по экрану, уменьшение здоровье персонажа и так далее.

Render
Функция занимается отображением всего на экране. Она НЕ обрабатывает манипуляции с данными - этим занимается Loop.

Cleanup
Функция просто отключает все использующиеся ресурсы и закрывает игру.

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

1
2
3
4
5
6
7
8
9

Initialize();
 
while(true) {
    Events();
    Loop();
    Render();
}
 
Cleanup();

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

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

1
2
3
4
5
6

if(Key == LEFT) X--;
if(Key == RIGHT) X++;
if(Key == UP) Y--;
if(Key == DOWN) Y++;
 
RenderImage(KnightImage, X, Y);

Это работает, потому что каждый цикл проверяется, нажата ли кнопка ВЛЕВО, ВПРАВО и т.д., и если да, то уменьшить или увеличить переменную. Так что, если наша игра идет со скоростью 30 кадров в секунду и мы нажимаем НАЛЕВО, то рыцарь будет двигаться влево со скоростью 30 пикселей в секунду. Если вам еще не удалось разобраться в принципе игрового цикла, то вы скоро с этим справитесь. Цикл необходим, чтобы игра правильно функционировала.

Возвращаясь к нашему концептуальному коду (5 функций), мы можем добавить эти дополнительные функции в наш проект, в файле App.h:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#ifndef _APP_H_
#define _APP_H_
 
#include <SDL.h>
 
class App {
    private:
        bool    Running;
 
    public:
        App();
        int Execute();
 
    public:
        bool Init();
        void Event(SDL_Event* Event);
        void Loop();
        void Render();
        void Cleanup();
};
 
#endif

А в файле App.cpp:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

#include "App.h"
 
App::App() {
    Running = true;
}
 
bool App::Init() {
    return true;
}
 
int App::Execute() {
    if(Init() == false) {
        return -1;
    }
 
    SDL_Event Event;
 
    while(Running) {
        while(SDL_PollEvent(&Event)) {
            Event(&Event);
        }
 
        Loop();
        Render();
    }
 
    Cleanup();
    return 0;
}
 
int main(int argc, char* argv[]) {
    App App;
    return App.Execute();
}
 
void App::Event(SDL_Event* Event) {}
void App::Loop() {}
void App::Render() {}
void App::Cleanup() {}

Вы видите несколько новых переменных, но давайте сначала разберемся что же делает этот код. Во-первых, мы пытаемся инициализировать нашу игру, если не вышло - мы возвращаем -1 (код ошибки), тем самым закрывая программу. Если все хорошо, то мы входим в игровой цикл. В цикла мы используем SDL_PollEvent для проверки событий и передаем их по одному в Event. После этого, мы идем в Loop для перемещения данных вокруг, и всего в таком роде, а затем отображаем нашу игру. Повторяем это бесконечно. Если пользователь выходит из игры, мы попадаем в Cleanup, которая освободит используемые ресурсы. Вот так, достаточно просто.

Теперь, давайте посмотрим на SDL_Event и SDL_PollEvent. Первое - это структура, которая содержит информацию о событиях. Вторая функция, которая будет захватывать любые события, ожидающие в очереди. Очередь может состоять из любого количества событий, поэтому мы должны перебрать их по очереди. Например, позволяет нажимает кнопку А и перемещает мышь, в тот момент, когда исполняется Render(). SDL обнаружит это и поставит два события в очередь, по одному на каждое нажатие клавиши и перемещение мыши. Мы получаем эти события из очереди с помощью SDL_PollEvent, а затем передаем его в Event, чтобы обработать соответствующим образом. Когда в очереди нет событий, SDL_PollEvent вернет false, выйдя из цикла обработки событий.

Другая добавленная переменная Running - это наш выход из цикла игры. Если оно false, значит игра закончилась, и надо выйти из программы. Так что, если, например, если пользователь нажимает клавишу ESC мы можем присвоить ей false, и тем самым выйти из игры.

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

Теперь, когда все настроено, давайте создадим окно, где будет отрисовываться наша игра. Откройте App.h и добавить переменную поверхности SDL:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#ifndef _APP_H_
#define _APP_H_
 
#include <SDL.h>
 
class App {
    private:
        bool    Running;
        SDL_Surface*    Screen;
 
    public:
        App();
        int Execute();
 
    public:
        bool Init();
        void Event(SDL_Event* Event);
        void Loop();
        void Render();
        void Cleanup();
};
 
#endif

Думаю, самое время объяснить что такое SDL поверхность. SDL поверхность это все, что можно нарисовать, и все на чем можно нарисовать. Например, у нас есть лист бумаги, карандаш, и стикеры. Бумаги можно назвать поверхностью. Мы можем рисовать на ней, наклеивать стикеры и прочее. Стикеры тоже можно считать поверхностями, мы можем рисовать и на них, и наклеивать другие стикеры поверх. Таким что, Screen - это просто наш "лист бумаги", на котором мы будем рисовать.

Теперь, давайте отредактируем функцию Init, чтобы инициализировать эту поверхность:

1
2
3
4
5
6
7
8
9
10
11

bool App::Init() {
    if(SDL_Init(SDL_INIT_EVERYTHING) > 0) {
        return false;
    }
 
    if((Screen = SDL_SetVideoMode(640, 480, 32, SDL_HWSURFACE | SDL_DOUBLEBUF)) == NULL) {
        return false;
    }
 
    return true;
}

Первое, что нужно сделать, это запустить собственно SDL, чтобы мы могли получить доступ к его функциям. Мы командуем SDL инициализировать все, что доступно; есть различные параметры, которые можно передать, но это на данный момент это не важно. Следующая функция: SDL_SetVideoMode. Она и создаст наше окно и поверхность. Она принимает 4 параметра: ширину окна, высота окна, битовое разрешение (рекомендуется 16 или 32), и различные флаги отображения. Есть довольно много флагов, но тех, которые мы используем, достаточно на данный момент. Первый флаг говорит SDL использовать аппаратную памяти для хранения изображений, а второй говорит SDL использовать двойную буферизацию (это предотвратит мерцание на экране). Еще один флаг, который может заинтересовать вас - это SDL_FULLSCREEN, он запускает приложение в полноэкранном режиме.

Теперь, когда окно настроено, давайте сделаем так, чтобы все работало гладко. Изменим функцию App::Cleanup() и добавим следующее:

1
2
3

void App::Cleanup() {
    SDL_Quit();
}

Мы просто выходим из SDL. Надо учесть, что в этой функции, мы будем освобождать использованные поверхности

Чтобы все было аккуратно, надо также инициализировать указатель Screen значением NULL, в конструкторе класса. В App.cpp добавить следующее:

1
2
3
4

App::App() {
    Screen = NULL;
    Running = true;
}

Попробуйте скомпилировать проект, посмотрите как он работает. Должно появится пустое окно. Его все еще нельзя закрыть просто так, придется воспользоваться диспетчером задач. Это не очень удобно, поэтому давайте исправим ситуацию. Изменим функцию Event:

1
2
3
4
5

void App::Event(SDL_Event* Event) {
    if(Event->type == SDL_QUIT) {
        Running = false;
    }
}

SDL события различаются по типу. Эти типы могут варьироваться от нажатия клавиш, движения мыши, все что нам нужно это проверить его тип. Нужный нам тип - это запрос на закрытие окна (например, когда пользователь нажимает кнопку X). Если это событие произойдет, мы устанавливаем Running = false, тем самым завершив нашу программу. Достаточно просто. Мы рассмотрим больше событий в других статьях.

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

В качестве компилятора можно испорльзовать GCC и G++. Есть 2 пакета, откуда его можно получить: Cygwin и MinGW. Свою эпопею я начал с MinGW, но проблема в том, что make в MinGW не поддерживается NetBeans, и надо будет доустанавливать MSYS, которая находится на том же сайте. Кроме того внутренний терминал NetBeans будет работать только с Cygwin. Поэтому в итоге я пришел к тому, что у меня стоит Cygwin.

Устанавливайте Cygwin в папку без пробелов, если вы большой любитель порядка и хотите его всенепременно в Program Files - сделайте символическую ссылку C:/cygwin -> C:/Program Files/Cygwin, как это сделал я. При установке выберите gcc, g++, gdb, make и все, что он вам еще предложит, не откладывайте инсталлер далеко, вероятно, придется доустановить библиотеки libintl-3, libintl-8, libiconv, libncursesw. Не могу точно сказать что он сделает автоматически, потому как на момент установки у меня уже было скачано несколько библиотек вручную.

После установки Cygwin в NetBeans открывайте Tools -> Options -> C/C++, на первой вкладке Build Tools нажимайте Add и указывайте путь к папке C:/cygwin/bin, откуда NetBeans должен подцепить компиляторы и подставить их в нужные поля.

На этом настройка IDE закончена, вы можете создать C++ проект (обратите внимание, вы создаете C/C++ проект, выбор между собственно C и C++ происходит в маленьком выпадающем меню справа, рядом со строкой Create Main File. Если у вас будет С проект, и вы, например заинклюдите , компилятор будет ругаться, что нет такого файла.

Время настроить SDL. С сайта скачиваем SDL-devel-1.2.14-mingw32.tar.gz. Оттуда копируем в наш проект папку lib, include, а из папки bin кладем SDL.dll в корень проекта. Далее идем в свойства проекта:
1. Build -> C++ Compiler -> General -> Include Directories и добавляем папку include/SDl, а так
же укажем -O3 в Additional Options.
2. Build -> Linker -> Additional Library Directories указываем папку lib, в Libraries добавляем файлы (Add Library File) libSDLmain.dll.a, libSDLmain.a в этом же порядке. Если мы нажмем Additional Options, то увидим там в конце строку "-LSDL SDL/libSDLmain.a SDL/libSDL.dll.a", что есть хорошо.

Наконец, в main.cpp можно написать:

#include "include/SDL/SDL.h"
 
int main(int argc, char** argv) {
 
    SDL_Init(SDL_INIT_EVERYTHING);
    SDL_SetVideoMode(640, 480, 0, SDL_HWSURFACE | SDL_DOUBLEBUF);
    SDL_Quit();
 
    return 0;
}

Теперь можно нажать кнопку RUN и увидеть быстро моргнувшее окно SDL и надпись RUN SUCCESSFUL (total time: 326ms). Успех.

Ну и вот мы делаем такой финт ушами:

modules:
  class: sfDoctrineRouteCollection
  options:
    model:                modules
    module:               modules
    prefix_path:          /modules
    column:               module_id
    with_wildcard_routes: true
    object_actions:       { action1: GET, action2: GET }
  requirements:
    module_id:        \d+

В сгенеренный роут я добавил параметр object_action, после чего этот роут будет так же генерить роуты @modules_action1 и @modules_action2, что нам собственно и нужно. А GET - это тип запроса, на который будет отзываться новоделанный роут.

Как, наверное, некоторые из вас знают, 8 октября прошла конференция Symfony Day 2010 в Кёльне, на которой мне посчастливилось присутствовать. Я случайно наткнулся на сайт, http://www.symfonyday.com/, и сразу же решил, что хочу туда. Вход стоил 120 евро, но я успел как early bird за 80. Путь мой начинался с самой восточной границы Германии, и лежал почти до западной, более 550 километров, причем ночью. Не хотелось тратиться на гостиницу, а тут еще подвернулся вариант с CNL (ночным) поездом, я думал, что это вроде плацкартного. Как выяснилось, место у меня сидячее, в купе едут по 6 человек, спать было почти невозможно. Так что приехал я в Кёльн за 3 часа до конференции весьма измотанный.

На входе в медиа-центре Komed, где происходило действие, красовались флаги Symfony Day. Нам выдали беджики, и мы пошли в зал. Было еще рано, поэтому народу почти не было, зато на экране запустили Twitterwall - прямую трансляцию из Твиттера по хештегу #sfdaycgn, сделанную с помощью node.js. Я не преминул возможностью передать привет всем присутствующим от друзей из Russian Symfony User Group .

Первым выступал Jonathan Wage, который рассказал о работе Doctrine 2 с Mongo DB. Он вкратце обьяснил что же за зверь такой этот Mongo DB, и привел примеры, как с помощью Doctrine делать самые обычные действия - прочитать/вставить/удалить. Доклад был интересным, однако слушал я с трудом. Сказалась ночь в поезде и меня жутко клонило в сон. Не припомню когда я еще проявлял столько воли, чтобы не засыпать и не зевать. Сразу после я побежал заливаться кофе, а вы пока можете посмотреть слайды.

Вторым выступал core developer PHP Pierre Joye. Этот доклад был наполнен юмором. Если доклад Джонатана был вроде утренних новостей, то доклад Пьера как первая развлекательная передача дня. Рассказ был о том, как развивается PHP, какие есть недостатки, и что с этим можно делать. В зале нашелся человек, который до сих пор пользуется PHP4. Угадайте, какую CMF он использует? Правильно, Drupal. А вот вам цитатка:"A lot of idiots use PHP. For example.. (slide) Microsoft". Главным слайдом презентации можно считать "PHP is ugly". Да, разработчик PHP признает, что язык уродлив. Но мы же не художники в конце концов. Нам не о красоте надо думать, а о том, как создавать проекты, которые будут успешно работать. К тому же, если использовать Symfony, то недостатки заметны меньше. Да и помимо Symfony написано достаточно хороших фреймворков, и вряд ли есть большой спрос на новые. "Кто вообще писал новый фреймворк за последние два года",- вопрошал Пьер. Руку поднял один человек в зале - Фабьен Потенсьер Все засмеялись и заапплодировали. Важной мыслью было то, что PHP уже достиг того когда он почти никогда не является "бутылочным горлышком". "Если вам не хватает производительности PHP - то вы Facebook".

Пока был перерыв перед следующим докладом - я сделал фотографию зала. По количеству стульев можно прикинуть, что было человек 150. А выступал третьим Christian Schaefer (Кристиан Шефер), симфони-блоггер. Может я ошибаюсь, но мне показалось, что у него не очень большой опыт подобного рода выступлений - в основном он повторял то, что было написано на слайдах. Тем не менее, слушать было интересно. А речь шла о Unit-тестировании плагинов с помощью PHPUnit. О том, как все правильно настроить, и как тесты запускать.

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

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

Следующим выступал Гейлорд Олке (Gaylord Aulke). Этот доклад был, я думаю, не столько для программистов, сколько для работников отдела продаж. Гейлорд рассказал о том, как представить клиенту выбор, покупать готовый сайт, который можно просто запустить, или заказывать разработку, которая займет время, но зато проект будет соответствовать пожеланиям клиента. Есть еще третий вариант - построить проект из модулей.

Последним выступал Фабьен Потенсьер. Речь шла о Symfony2, которая должна быть готова к марту 2011. Во-первых, для темплейтов можно будет использовать шаблонизатор Twig. И хотя поддержка чистого PHP останется, Twig гораздо более прост для восприятия и использования непрограммистом. Пользователь, как объект, теперь не привязан к сессии, пользовательские данные можно будет хранить в конфиг-файле (например, если нужен только один админ), можно будет одновременно аутентифицировать пользователей через БД, LDAP и конфиг файлы. Формы можно будет показывать с помощью темплейтов, того же твига. В общем масса изменений, все будет супер-круто. Ну и приложу слайд, который будет во всех блогах и отчетах про конференцию

Фабьен дольше всех отвечал на вопросы, что в общем неудивительно. Когда все закончилось в холле было бесплатное пиво, небольшой конкурс с призами (я ничего не выиграл), можно было набрать наклеек. Ощущения, конечно, самые позитивные. Больше всего понравились выступления Пьера Жойе и Фабьена Потенсьера, а самым полезным я считаю доклад Криса Уолсмита. Приложу еще фотографию Кёльнского собора, раз уж я там был, грех был бы не посмотреть.

Через пару часов я сел на поезд и отправился домой, опять более чем 550 километров сидя, ночью. Поспать мне опять не удалось и после двух бессонных ночей чувствовал я себя.. да почти не чувствовал. Но эти мелочи не могли повлиять на удовольствие, которое я получил на конференции: побыл среди умных людей, послушал выступления и вообще классно провел время.

Для эксперимента еще выложил фотографии на flickr.

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

Обычно я убираю названия плагинов/модулей из листингов, но в данном случае ради наглядности и простоты понимания я их оставлю. Плагин называется wePages, модуль wePages_frontend. И вот значит что мы будем делать в конфигурации:

public function initialize() {
  if (in_array('wePages_frontend', sfConfig::get('sf_enabled_modules', array()))) {
    $this->dispatcher->connect('routing.load_configuration', array('wePagesRouting', 'listenToRoutingLoadConfigurationEvent'));
  }
}

Если наш модуль числится в списке подключенных, то подключаем listener по имени listenToRoutingLoadConfigurationEvent из файла wePagesRouting к событию routing.load_configuration. Проще говоря, когда загрузится конфигурация роутов будет вызвана наша функция.

Создадим файл /lib/routing/wePagesRouting.class.php, куда поместим нашу функцию.

class wePagesRouting {
 
  /**
   * Listens to the routing.load_configuration event.
   *
   * @param sfEvent An sfEvent instance
   * @static
   */
  static public function listenToRoutingLoadConfigurationEvent(sfEvent $event) {
    $r = $event->getSubject();
 
    // Узнаем максимальную глубину дерева
    $maxlvl = Doctrine_Query::create()->
              select('MAX(level) as maxlvl')->
              from('wePages')-> 
              execute()->
              getFirst()->
              getMaxlvl();
 
    // В конфигурации мы можем указать префикс для роута, 
    // например '/page', начинаться же он должен со слеша, 
    // что мы и проверяем
    // prefix must have '/' 
    if (trim(sfConfig::get('app_we_pages_plugin_route_prefix', ''))) {
      $route_pattern = '/'.trim( sfConfig::get('app_we_pages_plugin_route_prefix', ''), '/');
    } else {
      $route_pattern = '';
    }
 
    // Здесь мы создаем строчку, на соответствие которой в роутинге 
    // будет проверятся URL, тут-то и кроется вся магия. 
    // Мы создаем роут с количеством слагов равным максимальной 
    // глубине дерева, чтобы охватить все страницы, а в качестве 
    // значения по умолчанию ставим false, чтобы роут срабатывал 
    // и на меньшем количестве слагов
    $defaults = array();
    for ($i = 0; $i <= $maxlvl; $i++) {
      $route_pattern .= '/:slug'.$i;
      $defaults['slug'.$i] = false;
    }
 
    // осталось теперь только подключить роут к уже загруженным, 
    // важно чтобы он был первым
    // preprend our routes
    $route = new wePagesRoute(
        $route_pattern, 
        array_merge( 
            array( 'module' => 'wePages_frontend', 'action' => 'show' ), 
            $defaults 
        )
    );
    $r->prependRoute('wePages_frontend', $route);
  }
 
}

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

Обратите внимание, что мы создали объет не sfRoute, а wePagesRoute. Этот класс лежит в соседнем файле wePagesRoute.class.php. Нам ведь надо проверять довольно специфические условия, поэтому стандартный класс не подходит.

class wePagesRoute extends sfRoute {
  // функция проверяет подходит ли данный роут под указанный URL
  public function matchesUrl($url, $context = array()) {
    // если шаблон роута не совпадает - дальше даже не смотрим
    if (false === $parameters = parent::matchesUrl( rtrim($url, '/') , $context)) {
      return false;
    }
    // преобразуем наши сгенерированные слаги в массив, 
    // где ключи - это глубина элемента в дереве,
    // а значения - сами слаги.
    // почему так? у нас же рекурсивный роут и начинается 
    // с верхнего уровня, который имеет level = 0
    // соответственно следующие слаги имеют level = 1,2,3..
    // make slug1, slug2.. into array [0] => 'slug1', [1] => 'slug2'
    $i = 0;
    $pages = array();
    while (isset($parameters['slug'.$i]) && strlen(trim($parameters['slug'.$i]))) {
      $pages[$i] = $parameters['slug'.$i];
      $i++;
    }
 
    // если выяснилось, что слагов не указано - бросаем это дело
    // If we dont have any slugs - we dont want this anymore
    if (empty ($pages)) {
      return false;
    }
    // Второй важный момент
    // Мы берем слаги и уровни, и ищем страницы подходящие под условия. 
    // Данный способ не работает, если slug не уникальны.
    // Groupby объединяет элементы с одинаковым уровнем
    // Get pages with these slugs and levels
    $data = Doctrine_Query::create()
        ->from('wePages')
        ->andWhereIn('slug', array_values($pages))
        ->andWhereIn('level', array_keys($pages))
        ->orderBy('level ASC, lft ASC')
        // this group by removes entries with same level
        ->groupBy('level')
        ->execute();
 
    // теперь внимательно смотрим, если нашли страниц меньше, 
    // чем было указано слагов то URL не совпадает с иерархией в БД, 
    // а значит, извините, но вы не по адресу.
    // искали 3 слага - надо найти 3 страницы, и чтобы их level 
    // были равны 0,1,2 и не повторялись
    // проблемы начнутся, если слаги могут совпадать, 
    // но другого быстрого и простого способа проверить я не придумал
    // If some url parts dont fit - dont want this anymore
    if (count($data) < count($pages)) {
      return false;
    }
 
    // если мы не указали в конфигурации префикс 
    // и страницы вызываются, как www.site.com/page1
    // то этот роут будет выполнятся довольно часто, 
    // поэтому раз уж мы выполнили поиск страниц
    // было бы глупо не передать уже найденный id в метод show,
    // или что там у вас для показа
    $parameters['page_id'] = $data->getLast()->getId();
 
    return $parameters;
  }

У меня этот метод прекрасно заработал, хотя и не является идеальным решением. Если я хочу создать страницы /team/men, /team/women, то мне придется создавать и страницу /team, и она будет открываться, хотя я, например, хотел бы чтобы она редиректила на /team/men. То есть надо было бы создавать тип страниц "редирект". Что порядком костыльно. Так же, вероятно, будут проблемы с link_to и url_for. Стоит написать свой хелпер для генерации урлов.

Что еще можно сделать? Можно при создании страницы указывать URL напрямую, и хранить его в БД. И точно так же в роуте проверять не соответствие слагов и уровней, а просто искать по полю url. Позволяет обойти проблему с /team/men, хотя и не очень красиво, страница /team, будет выдавать 404. Хотя как я понимаю, проблему с link_to оно все равно не решит.

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

public function  setupInheritance() {
    parent::setupInheritance();
 
    $this->widgetSchema['parent'] = new sfWidgetFormDoctrineChoiceNestedSet(array(
        'model' => 'MODEL_NAME',
        'add_empty' => true
    ));
    $this->validatorSchema['parent'] = new sfValidatorDoctrineChoice(array(
        'model' => 'MODEL_NAME', 
        'required' => false
    ));
}

Добавили виджет и валидатор. sfWidgetFormDoctrineChoiceNestedSet это простой DoctrineChoice, в котором есть отступы и сортировка в соответствии с иерархией в NestedSet. Теперь наш виджет виден в форме, правда ни на что пока не влияет.

Чтобы на что-то влиять, нам надо добавить его в список полей фильтра в том же файле.

public function getFields() {
    $fields = parent::getFields();
    $fields['parent'] = 'NestedNode';
 
    return $fields;
}

Здесь надо обратить внимание не только на значение, но и на имя ключа в массиве. В качестве значения можно указывать "Number", "Text", "Date" и некоторые другие. Я не пробовал, но полагаю, что если указать одно из них, то сработает стандартный обработчик поля фильтра, как например addNumberQuery. В нашем случае формат нестандартный и обработчик будем делать сами.

Кстати говоря, если в данный момент посмотреть на наш проект - нам выбросят исключение, где будет сказано как надо назвать метод, который будет обрабатывать наше поле. В моем случае это addParentColumnQuery. Формат названия функции, скорее всего такой: add_COLUMN_NAME_ColumnQuery.
А собственно вот и она сама:

public function addParentColumnQuery($q, $element, $value) {
    $parent = Doctrine::getTable('MODEL_NAME')->findOneById($value);
    return $q->andWhere('lft > ?', $parent->getLft())->andWhere('rgt < ?', $parent->getRgt());
}

Получаем Doctrine_Query в качестве параметра $q, добавляем свои условия и возвращаем. Все легко и просто.

Наздоровье
Референс: http://robert-says.com/2010/03/symfony-how-to-add-a-custom-filter-for-the-admin-listing/

$query->addWhere('level = ?', 0);

Это потому, что все, что ниже уровнем мы будем получать через getChildren. Иначе нам пришлось бы двигать итератор Doctrine_Collection, что более сложно, заумно, и вовсе у меня не получилось (next($objects) почему-то не дает эффекта).
Сделать optgroup в choice совсем несложно, надо лишь сделать элемент массивом. Ну а что получилось собственно внутри поста.

Я еще раз повторюсь, что это код sfWidgetFormDoctrineChoiceNestedSet, за малым изменением.

class weDoctineOptgroupSelectWidget extends sfWidgetFormDoctrineChoice {
 
  public function getChoices() {
    $choices = array();
    if (false !== $this->getOption('add_empty')) {
      $choices[''] = true === $this->getOption('add_empty') ? '' : $this->getOption('add_empty');
    }
 
    if (null === $this->getOption('table_method')) {
      $query = null === $this->getOption('query') ? Doctrine_Core::getTable($this->getOption('model'))->createQuery() : $this->getOption('query');
      // force manual sorting according to root_id then by lft
      $query->addOrderBy('root_id asc')
          ->addOrderBy('lft asc');
      // Viktoras: we need to fetch only top level, as we'll get the children with getChildren()
      $query->addWhere('level = ?', 0);
      $objects = $query->execute();
    } else {
      $tableMethod = $this->getOption('table_method');
      $results = Doctrine_Core::getTable($this->getOption('model'))->$tableMethod();
 
      if ($results instanceof Doctrine_Query) {
        $objects = $results->execute();
      } else if ($results instanceof Doctrine_Collection) {
        $objects = $results;
      } else if ($results instanceof Doctrine_Record) {
        $objects = new Doctrine_Collection($this->getOption('model'));
        $objects[] = $results;
      } else {
        $objects = array();
      }
    }
 
    $method = $this->getOption('method');
    $keyMethod = $this->getOption('key_method');
 
    foreach ($objects as $object) {
      // indent item by 4 spaces per level
      // Viktoras: here we check for children and make entry an array if they exists
      $node = $object->getNode();
      if ($node->hasChildren()) {
        foreach ($node->getChildren() as $child) {
          $choices[$object->$method()][$child->$keyMethod()] = str_repeat(' ', ($child['level'] * 4)) . $child->$method();
        }
      } else {
        $choices[$object->$keyMethod()] = str_repeat(' ', ($object['level'] * 4)) . $object->$method();
      }
 
    }
    return $choices;
  }
 
}

И выглядит это вот так:

Как вообще убрать фильтры в admin generator?

config:
  filter:
    class: false

Как повесить иконку своему кастомному object_action?

#sf_admin_container ul li.sf_admin_action_##ACTION_NAME## a
{
  background: url(/images/icons/icon.png) no-repeat 0 0;
}

Как недопустить ввода пустой строки в админке?

public function configure() {
    $this->validatorSchema['name']->setOption('trim', true);
}

Fatal error: Call to undefined function include_component()
Вы, скорее всего, указали в settings.yml standart_helpers, и забыли добавить в список Partial.

all: 
  .settings: 
    standard_helpers:       [I18N, Partial]

За день до поездки мы искали отель, так как собирались пробыть в Праге два дня, а так же изучали карту города и смотрели сайты ресторанов, выбирая поинтереснее и подешевле. Сразу дам ссылочку на сайт, который нам сильно помог. Как раз там мы и заказали номер. Изначально хотели взять что подешевле, но все оказалось уже занятым, поэтому взяли номер на двоих в 4х-звездочном небольшом отеле Antik за 60 евро, включая завтрак. Чуть забегая вперед скажу, что это составило чуть меньше половины всех наших затрат на это путешествие.

Отправились мы из Zittau в 8:45 на поезде до города Liberec. Билеты купили заранее, стоили они всего €2,60 на человека. Дорога заняла всего 35 минут, и в 9:20 мы уже были на месте.

Либерецкий вокзал на ремонте и выходить пришлось какими-то грязными корридорами. Как вышли - побежали на автобусный вокзал, уж очень хотели успеть на автобус на 10 часов. Для чешских автобусов есть очень удобный сайт Student Agency, где можно заказать билет заранее и оплатить, а потом при входе просто сказать номер своей брони. При бронировании можно увидеть сколько мест осталось свободно и выбрать какие именно места хотите.

И вот за день до отъезда я хотел забронировать нам места в автобусе на 10 часов, но к сожалению, моя банковская карта не подходит для оплаты через интернет, а мест в автобусе оставалось всего 7. К нашему счастью мы успели купить билеты. До отправления оставалось около 30 минут, так что мы немного погуляли вокруг вокзала, или как его там называют Nádraží.

Ровно в 10 часов подошел наш автобус, такие называют coach. Наши места были 29,30 — как раз напротив входа. Здесь мы были порядком удивлены. За билеты мы заплатили 160 чешских крон, что равно примерно 6 евро. При этом в автобусе было несколько экранов, где можно было смотреть сериал «Друзья» на английском с чешскими субтитрами, для этого бесплатно выдаются наушники. Кроме того стюардесса бесплатно приносит горячие напитки (чай, кофе, горячий шоколад), а для желающих есть туалет. Хотелось встряхнуть головой и протереть глаза, неужели и правда это все за 3 евро с человека. И ведь еще везут куда надо... поразительно. Через 1 час и 5 минут мы приехали в Прагу. Всего получается мы потратили на дорогу 2 часа и 11 евро.

Прибыли мы на автобусный вокзал, где находится станция метро Černý Most. Я думаю несложно догадаться, что по-русски это будет «Черный мост». Вход в метро здесь немного похож на финский, никаких тебе турникетов, только стойки для компостирования билетов. Вот чего я вам не советую, так это приезжать в Прагу в воскресенье - кассы не работают, а автоматы принимают только монеты. Так что с вашими евро, или банкотами из банкомата, придется искать место, где продают билеты.

Благо они бывюат в газетных киосках, да и вообще в магазинах рядом с метро. Билеты тут действуют определенное количество времени. Есть билет на 20 минут за 18 крон, но на нем далеко не уедешь. Чтобы доехать до центра от Černý Most — берите лучше билет за 26 крон, он будет действовать 75 минут с момента активации. Можно так же взять билеты на 1-3-5 дней (100-330-500 крон соответственно).

При входе в любой транспорт неактивированный билет надо активировать, засунув его в специальный аппарат. Как раз такие и стоят на входе в метро. Будьте внимательны, компостируйте с правильной стороны! Когда мы уже ехали обратно, моя жена неправильно прокомпостировала билет. Заметили не сразу, но решили, что ничего страшного. Так вот у нас обошлось, но вообще штраф 1000 крон, независимо от того что вы иностранец и не понимаете их язык и как у них все устроено. Лучше не рискуйте, берите билет и езжайте спокойно, к тому же стоит он совсем не дорого. (На фото, как видите, один билет не прокомпостирован снизу).

Метро в Праге состоит из 3х линий: зеленая линия А, желтая B и красная C. Černý Most — это конечная станция желтой линии. Когда мы, уже на следующий день, возвращались мы проехали одну станцию по красной линии, а на зеленой так и не побывали. На красной линии нам попался поезд поновее, сидения там были мягче, а двери открывались как в автобусе, немного выезжая вперед.

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

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

На метро мы приехали на станцию Náměstí Republiky. Регистрироваться в отеле можно было с 2х часов дня, а было, я напомню, всего 11, поэтому мы пошли гулять. Нас сразу впечатлила Пороховая башня (Prašná brána) и мы захотели поднятся на нее. Внутри была довольно длинная винтовая лестница и подниматься порядком утомило.

Сперва поднялись до первого внутреннего зала, где стояли доспехи рыцаря, разное оружие старых времени, старинные книги на чешском и все такое прочее. Вместо окон в башне почти везде были витражи. В этом же зале надо платить за вход, по-моему что-то около 100 крон (4 евро). Дальше опять подъем по винтовой лестнице и еще один зал, теперь со сценой средневековой битвы. И наконец, последнее усилие, и мы наверху.

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

Дальше наш путь лежал по Целетной улице (Celetná ulice) до очень красивой Староместской площади (Staroměstské náměstí). На самой площади, конечно, было множество народу. На вертелах жарились большие куски свинины и заманчиво пахли. Стоит это удовольствие 85 крон (3 евро) за 100 граммов и мы решили лучше потерпеть потом до ресторана. Так же на площади происходило какое-то событие, была сцена и большой экран, передающий события на сцене. Выступал этнический коллектив с немецкими песнями.

Спонсором, видимо, была марка машин Hyundai, потому что сцена и экран, и еще какие-то инсталляции были облеплены логотипами. Чуть-чуть послушали и пошли дальше. Мимо астрономических часов, рядом с которыми толпились люди. Оказалось, что времени было без десяти час, а в час что-то должно было произойти. И произошло. Фигурки рядом с часами задвигались:

скелет дергал за веревочку и тем самым звонил в колокол, фигура турка (как мы услышали у экскурсовода неподалеку) трясла палкой, с другой стороны часов фигурка лицемерия смотрелась в зеркало, а «жадность» трясла мешком с деньгами. Потом золотой петух над часами прокукарекал, с верхнего этаже здания с часами высунулся трубач и протрубил мелодию. Такое вот небольшое представление. Мы пошли дальше по улице до Карлового моста (Karlův most) через Влтаву. На мосту тоже было много народу, идти приходилось почти проталкиваясь. На перилах были скульптуры, играла какая-то группа и продавала диски, художники предлагали картины, фотографии. На другой стороне моста мы поняли, что уже порядком устали и проголодались.

В мои планы входило прогуляться дальше, я не расчитывал что мы так сильно захотим есть в это время, и не искал ресторанов в том районе. Поэтому решили идти в McDonald's, это было проще всего. Когда покушали, время уже перевалило за 2 часа, поэтому мы отправились в отель.

Некоторые люди утверждают, что Symfony - это подарок богов. Другие считают, что это преувеличение. Но как ни крути, в версиях 1.3/1.4 добавилось много нового и полезного, что может сэкономить вам вермя.
Представим проект, где есть разные заметки (новости, интервью, и т.д.). И они могут быть на разных языках. И это довольно просто сделать с actAs: I18n. Но есть небольшая сложность: переводы должны быть опциональны, чтобы можно было написать статью только на французском, английском или немецком.

Некоторые материалы по теме: раз, два, три, четыре, пять.

Итак, начнем со схемы.

Article:
  actAs:
    Timestampable: ~
    I18n:
      fields: [ title, body ]
      actAs:
        Sluggable: { fields: [ title ], uniqueBy: [ lang, title ] }
 
  columns:
    title: { type: string(255), notnull: true }
    body: { type: clob, notnull: true }
    author: { type: string(255), notnull: false }
 
News:
  inheritance:
    extends: Article
    type: concrete

А так же фикстуры:

News:
  n1:
    author: 'Lenta.ru'
    Translation:
      ru:
        title: 'Нет вестей с Титана'
        body: |
          Титан – это шестой и самый крупный спутник Сатурна.
 
  n2:
    author: 'Bash.org'
    Translation:
      en:
        title: '#921792'
        body: |
          <Thomas> if women think they arent meant to cook
          <Thomas> why do they have milk and eggs inside them?

Загружаем все это добро в базу данных:

php symfony doctrine:build --all --and-load
php symfony generate:app backend
php symfony doctrine:generate-admin backend News

Загляните в только что построенный модуль админки. Нажмите кнопку "редактировать" и оп.. а где все наши переводы? Если вы еще не в курсе, actAs:I18n разделяет таблицу на 2 части, в первой содержатся общие поля, не зависящие от перевода, а во второй те, которые требуют перевода.

mysql> SELECT * FROM news;
+----+-------------+---------------------+---------------------+
| id | author      | created_at          | updated_at          |
+----+-------------+---------------------+---------------------+
|  1 | Lenta.ru    | 2010-01-29 12:14:46 | 2010-01-29 12:14:46 | 
|  2 | Bash.org    | 2010-01-29 12:14:46 | 2010-01-29 12:14:46 | 
+----+-------------+---------------------+---------------------+
 
mysql> SELECT id, lang, title FROM news_translation;
+----+------+-----------------------------------------------------+
| id | lang | title                                               |
+----+------+-----------------------------------------------------+
|  1 | ru   | Титан – это шестой и самый крупный спутник Сатурна. | 
|  2 | en   | <Thomas> if women think they arent meant to cook ...| 
+----+------+-----------------------------------------------------+

Чтобы нам было доступно редактирование переводов - надо воспользоваться функцией embedI18n.

// lib/form/doctrine/NewsForm.class.php
class NewsForm extends BaseNewsForm
{
  /**
   * @see ArticleForm
   */
  public function configure()
  {
    parent::configure();
    $this->embedI18n(array('ru', 'en'));
  }
}

Вуа ля. Редактировать можно!

Немного приберемся

Наш код сейчас не так хорош, как мог бы быть:
Каждый раз, когда мы будем добавлять новый тип статьи - нам надо будет менять метод configure;
Каждый раз, когда мы будем добавлять/удалять новый язык для статей - нам надо будет менять все формы.

К счастью, с Symfony 1.3, наследование форм повторяет наследование моделей. Смотрите, NewsForm наследует BaseNewsForm, которая в свою очередь наследует ArticleForm.

# config/app.yml
all:
  cultures:
    enabled:
      ru: Russian
      en: English

// lib/form/doctrine/NewsForm.class.php
 
// Revert the changes we added there
class NewsForm extends BaseNewsForm
{
  /**
   * @see ArticleForm
   */
  public function configure()
  {
    parent::configure();
  }
}
 
// lib/form/doctrine/ArticleForm.class.php
class ArticleForm extends BaseArticleForm
{
  /**
   * Available languages
   *
   * @var array $languages
   **/
  protected $langages;
 
  public function configure()
  {
    $this->languages = sfConfig::get('app_cultures_enabled');
 
    $langs = array_keys($this->languages);
 
    $this->embedI18n($langs);
    foreach($this->languages as $lang => $label)
    {
      $this->widgetSchema[$lang]->setLabel($label);
    }
  }
}

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

Редактируем переводы

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

// lib/form/doctrine/ArticleForm.class.php
class ArticleForm extends BaseArticleForm
{
  /**
   * Available languages
   *
   * @var array $languages
   **/
  protected $langages;
 
  public function configure()
  {
    $this->languages = sfConfig::get('app_cultures_enabled');
 
    $langs = array_keys($this->languages);
 
    $this->embedI18n($langs);
    foreach($this->languages as $lang => $label)
    {
      $this->widgetSchema[$lang]->setLabel($label);
    }
  }
 
  /**
   * Cleans and binds values to the current form
   *
   * Ignore i18n forms when all their fields are empty
   *
   * @see sfForm::doBind
   **/
  protected function doBind(array $values)
  {
    foreach($this->languages as $lang => $label)
    {
      if($this->embeddedI18nFormIsEmpty($values[$lang]))
      {
        unset(
          $values[$lang],
          $this[$lang]
        );
      }
    }
 
    parent::doBind($values);
  }
 
  /**
   * Check if every fields, except for id and lang, are empty
   **/
  protected function embeddedI18nFormIsEmpty(array $values)
  {
    foreach($values as $key => $value)
    {
      if(in_array($key, array('id', 'lang')))
        continue;
 
      if('' !== trim($value))
      {
        return false;
      }
    }
    return true;
  }
}

В перекрытом методе doBind, мы проверяем каждую I18n форму, и, если надо делаем ей unset. Теперь все сохраняется как надо, однако же...

Загляните в базу данных, вас там ждет сюрприз.

mysql> SELECT id, lang, slug FROM news_translation;
+----+------+------------------------------------------------------+
| id | lang | slug                                                 |
+----+------+------------------------------------------------------+
|  1 | en   |                                                      | 
|  1 | ru   | Титан – это шестой и самый крупный спутник Сатурна.  | 
|  2 | en   | <Thomas> IF women think they arent meant TO cook ... | 
+----+------+------------------------------------------------------+

Где-то в процессе сохранения, Symfony создала пустой объект перевода. И вот решение для этой проблемы.

// lib/form/doctrine/ArticleForm.class.php
 
  // Add this at the beginnig of the class:
  /**
   * I18n ignored forms
   **/
  protected $I18nFormsIgnored = array();
 
  // update the doBind method:
  /**
   * Unset i18n forms values when every field is empty
   **/
  protected function doBind(array $values)
  {
    foreach($this->languages as $lang => $label)
    {
      if($this->embeddedI18nFormIsEmpty($values[$lang]))
      {
        $this->I18nFormsIgnored[] = $lang;
        unset(
          $values[$lang],
          $this[$lang]
        );
      }
    }
 
    parent::doBind($values);
  }
 
  // And override the doUpdateObject method:
  /**
   * Updates the values of the object with the cleaned up values.
   *
   * @param  array $values An array of values
   *
   * @see sfFormDoctrine::doUpdateObject()
   */
  protected function doUpdateObject($values)
  {
    parent::doUpdateObject($values);
 
    foreach($this->I18nFormsIgnored as $lang)
    {
      unset($this->object->Translation[$lang]);
      unset($values[$lang]);
    }
  }

На этот раз все сохраняется как надо!

(Здесь я пропускаю абзац про убирание поля Slug. Там есть сложность с тем, что формы перевода не наследуются. Если вам интересно - посмотрите в оригинальной статье. Я считаю, что основное здесь - как раз перекрытие методов doBind и doUpdateObject.
Тесты, приведенные автором можно посмотреть у него в статье, а можно тут и тут).

На этом все. Надеюсь вам пригодится мой перевод.

В этом блоге почти все время я писал о PHP и немного о JS. Настало время разнообразить, и разнообразить свой блог я решил Питоном. О том, где взять Python и где поучиться я не буду, материалов полно, и большинство друг друга повторяют, в еще одном от меня смысла я не вижу. Чуть меньше примеров и статей про PyGame - свободную графическую библиотеку, базирующуюся на SDL.

Проблем с установкой, я надеюсь у вас не возникнет - либо запускате Windows инсталлер, а если вы в Linux - наверняка сами знаете. Не будем тянуть кота за хвост, откроем IDE, создадим проект и уже создадим хотя бы окошко.
main.py

#! /usr/bin/python
# -*- coding: utf-8 -*-
import pygame
 
class Game():
    def __init__(self):
        #Initial window settings
        pygame.init()
        pygame.display.set_mode((640, 480))
        pygame.display.set_caption('I\'m super cool Python programmer')
        self.run()
 
    #Run, Forrest, run
    def run(self):
        while True:
            self.track_input(pygame.event.get())
 
    def track_input(self, events):
        for event in events:
            #Exit
            if event.type == pygame.QUIT:
                exit(0)
 
#Here we go
if __name__ == "__main__":
    Game()

Сохраняете, запускаете, смотрите. Опа, окошечко. И даже закрывается по крестику. Теперь обьясню как это произошло. Сначала нам нужно импортировать pygame, иначе ничего не получится. Запуск скрипта начинается с последних строчек, которые создают экземпляр класса Game. Такая конструкция с переменной __name__ требуется для того, чтобы при импорте этой программы она не запускалась, а срабатывала только если файл запущен непосредственно. Функция __init__ в классе Game является чем-то вроде конструктора (но не конструктором!). Она вызывает метод pygame.init(), который инициализирует библиотеку, дальше вызываем метод pygame.display.set_mode((640, 480)), который и создает собственно окно размером 640х480. Обратите внимание, мы передаем кортеж, а не просто 2 числа. Дальше даем окну заголовок. На этом можно было бы и остановиться, программа уже будет работать. Но окно выскочит и закроется, потому что программа завершится. Чтобы этого не произошло запускаем функцию run(), которая представляет из себя бесконечный цикл вызовов функции track_input, которая принимает параметром события. И если произошло событие "Выход" (то самое нажатие по крестику), то закрываем. Все можно было бы уместить в одну функцию, но это задел на будущее.

Что же нам хочется дальше? Конечно же, чтобы что-то двигалось по стрелочкам. Почти в любой игре что-нибудь надо двигать, и у нас не будет исключение. Что же нужно? Нужно все так же следить за событиями, только теперь обрабатывать нажатия на кнопки стрелок. Чтобы удобнее было использовать направления (вверх, вправо, вниз, влево) обозначим их цифрами 0, 1, 2, 3. А чтобы не запутаться, введем переменные UP, RIGHT, DOWN, LEFT, которым и дадим эти значения. А переменные положим в отдельный файл directions.py и наступит ваще красота.
directions.py

#! /usr/bin/python
# -*- coding: utf-8 -*-
 
if __name__ == "__main__":
    exit(0)
 
UP    = 0
RIGHT = 1
DOWN  = 2
LEFT  = 3
DIRECTIONS = [UP, RIGHT, DOWN, LEFT]
VERTICAL = [UP, DOWN]
HORIZONTAL = [LEFT, RIGHT]

Обьявили наши переменные и три списка, которые нам пригодятся в будущем. Вернемся в main.py. Добавим к списку импортов directions.py:

import directions

В класс Game добавим словарь и 3 переменные:

x = 100
y = 100
speed = 3
 
keymap = {
    pygame.K_LEFT  : directions.LEFT,
    pygame.K_UP    : directions.UP,
    pygame.K_RIGHT : directions.RIGHT,
    pygame.K_DOWN  : directions.DOWN
}

Три переменные будут отвечать за положение и скорость перемещения объекта. А словарь ставит в соответствие клавиши и направления. Я надеюсь, что очевидно, что когда мы будем нажимать на какую-то кнопку, благодаря этому словарю мы узнаем в каком направлении надо двигать наш игровой объект, из положения x,y на speed пикселей. Далее в track_input добавляем в цикл:

if event.type == pygame.KEYDOWN and event.key in self.keymap.keys() and self.keymap[event.key] in directions.DIRECTIONS:
    self.move(self.keymap[event.key])

Здесь мы проверяем, что нажата кнопка (нажатия мышки и т.п. нас сейчас не интересуют) и что кнопка указана среди keymap, и то, что по выбранной кнопке в keymap стоит нормальное направление. И если все в порядке - вызываем функцию move с параметром "направление" из словаря.
В Python, насколько я знаю, нету операции switch/case, поэтому здесь мы будем делать финт ушами. Вот функция move, которую мы кладем все в тот же класс Game:

def move(self, direction):
    movement = {
        directions.UP       : [self.x,            self.y-self.speed],
        directions.RIGHT  : [self.x+self.speed, self.y],
        directions.DOWN  : [self.x,            self.y+self.speed],
        directions.LEFT    : [self.x-self.speed, self.y]
    }
    self.x, self.y = movement[direction]

Здесь у нас словарь с направлениями, по которым лежат списки с изменением параметров x и y, и когда вызывается нужное направление с помощью множественного присваивания мы изменяем сразу x и y.
Ну и наконец, в run() добавляем код, который будет рисовать нам маленький беленький квадратик, который и будет двигаться от наших нажатых кнопок.

pygame.display.get_surface().fill(pygame.Color(0, 0, 0, 0))
block = pygame.Surface((10, 10))
block.fill(pygame.Color(255, 255, 255, 0))
pygame.display.get_surface().blit(block, (self.x, self.y));
pygame.display.flip()

Давайте теперь посмотрим что у нас получилось.

#! /usr/bin/python
# -*- coding: utf-8 -*-
import pygame
import directions
 
class Game():
 
    x = 100
    y = 100
    speed = 3
 
    keymap = {
        pygame.K_LEFT  : directions.LEFT,
        pygame.K_UP    : directions.UP,
        pygame.K_RIGHT : directions.RIGHT,
        pygame.K_DOWN  : directions.DOWN
    }
 
    def __init__(self):
        #Initial window settings
        pygame.init()
        pygame.display.set_mode((640, 480))
        pygame.display.set_caption('I\'m super cool Python programmer')
        self.run()
 
    def run(self):
        while True:
            self.track_input(pygame.event.get())
            pygame.display.get_surface().fill(pygame.Color(0, 0, 0, 0))
            block = pygame.Surface((10, 10))
            block.fill(pygame.Color(255, 255, 255, 0))
            pygame.display.get_surface().blit(block, (self.x, self.y));
            pygame.display.flip()
 
    def track_input(self, events):
        for event in events:
            #Exit
            if event.type == pygame.QUIT:
                exit(0)
            if event.type == pygame.KEYDOWN and event.key in self.keymap.keys() and self.keymap[event.key] in directions.DIRECTIONS:
                self.move(self.keymap[event.key])
 
 
    def move(self, direction):
        movement = {
            directions.UP : [self.x,            self.y-self.speed],
            directions.RIGHT : [self.x+self.speed, self.y],
            directions.DOWN : [self.x,            self.y+self.speed],
            directions.LEFT : [self.x-self.speed, self.y]
        }
        self.x, self.y = movement[direction]
 
 
if __name__ == "__main__":
    Game()

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

Что касается алгоритма, то здесь все работает так. У нас есть поле 9х9, соответственно начнем мы с

public function generate() {
  $this->error_counter = 0;
  for ($row = 0; $row < 9; $row++) {
    for ($col = 0; $col < 9; $col++) {

$error_counter служит нам для защиты от тупиков. Сейчас вы увидите о чем речь.

if ($this->error_counter > self::retry_after) {
    //Row will be incremented to 0
    $row = -1;
    $col = 0;
    $this->error_counter = 0;
 
    $this->reset();
    break;
}

Если количество ошибок при генерации вышло за определенные пределы - значит звезды сложились неудачно и что-то где-то не сходится. Поэтому генерация сбрасывается и начинается заново.

if ($this->sudoku[$row][$col]->getNum() == 0) {
    //Вычисляем какие цифры подходят в текущую клетку
    $fit = $this->fit($row, $col);
 
    $percents = array();
    foreach (self::$numbers as $number) {
        $percents[$number] = $this->percentage($number, $row, $col, $fit);
    }
 
    //Here we get all numbers, that are most possible
    $available = array();
    $max = max(array_values($percents));
    foreach ($fit as $number) {
        if ($percents[$number] == $max) {
            $available[] = $number;
        }
    }

Вот тут и происходит вся магия. Сначала вычисляем какие числа могут встать в клетку (смотрим, чтобы по вертикали, горизонтали и в малом квадрате такой не было). Далее для каждого из этих чисел запускается мутная функция percentage. Она вычисляет, какой шанс у числа попасть в эту клетку. Допустим у нас осталось 4 свободные клетки и 4 числа. При этом первое число может попасть в 1 клетку из 4х, второе в две, третье в три, четвертое во все. Эта функция просто делит количество клеток куда число может попасть на количество пустых клеток. Таким образом, выпадет число, у которого меньше всего шансов попасть в другие клетки. При равенстве берем случайное.

//It can turn that sudoku generation isn't going well
if (count($available) == 0) {
    foreach ($this->sudoku[$row] as $cell) {
        $cell->setNum(0);
    }
    $row--;
    $this->error_counter++;
    break;
}

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

if ($this->error_counter > self::retry_after) {
    break;
}
$this->sudoku[$row][$col]->setNum($available[mt_rand(0, count($available)-1)]);

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

That's all folks.

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

Разделяемая память - особая область памяти, которая доступа ВСЕМ процессам операционной системы. Доступ к определенному сегменту можно получить с помощью двух параметров: имени существующего файла и одного символа, который будет ключом System V IPC. Это нужно для того, чтобы несколько сегментов могли быть выделены основываясь на одном и том же файле. Звучит пока очень туманно, но сейчас я приведу пример, и надеюсь все станет понятно.

$t_key = ftok(__FILE__, 'g');
$shmid = shmop_open($t_key, 'c', 0755, 64);
shmop_write($shmid, 1, 0);
shmop_close($shmid);

Первой командой, специальной функцией ftok мы получили ключ, по которому будем получать доступ к сегменту разделяемой памяти. Первым параметром мы передали ему имя файла скрипта, а вторым букву 'g'. Почему 'g'? А просто так, можно взять любой символ.
Во второй строке мы собственно открываем доступ к сегменту памяти. Первый параметр - наш ключ, второй параметр 'c' - флаг указывающий на то, что мы создаем сегмент памяти, при том, если он уже существуем - он открывается на чтение/запись. Третий параметр - права на доступ, четвертый - размер в байтах.
В третьей строке мы записываем туда единицу, последний параметр - смещение.
И наконец закрываем сегмент.
Теперь по адресу, который определяется файлом скрипта и буквой 'g' в сегменте размером 64 байта лежит единица, и ее может достать любой процесс.

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

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

$sem = sem_get(ftok(__FILE__, 'g'), 1);
sem_acquire($sem);
//тут может быть только один процесс
sem_release($sem);

Мы получаем ключ для семафора точно таким же образом, как и для разделяемой памяти. Третий параметр - автоматическое "отпускание" семафора, если поток, который был впущен завершился. Те потоки, которые попытаются получить доступ к семафору, будут блокированы до тех пор, пока семафор не освободится. Это похоже на очередь в туалет. Один внутри, остальные снаружи. Один выходит, другой заходит и закрывается, другие продолжают ждать.

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

//Ноль это наше начальное состояние счетчика
$counter = Counter::_new('g', 0);
//Порождаем потомков
for ($i = 0; $i < PROCESS_AMOUNT; $i++) {
    $pid = pcntl_fork();
 
    if ($pid == -1) {
        echo 'Error spawning new process';
    } elseif ($pid) {
        //Родительский процесс у нас ничего не будет делать
    } else {
        //Первый параметр - имя счетчика, и заодно часть ключа
        //Второй параметр - увеличивать ли значение счетчика
        //В данном случае мы просто читаем значение
        $counter = Counter::get('g', false);
        //TOTAL_LINES - количество строк в файле
        while ($counter < TOTAL_LINES) {
            //Берем значение счетчика и увеличиваем его на 1
            $counter = Counter::get('g', true);
            //Обарабатываем файл
        }
    }
}

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

Что такое многопоточность? Это способ разделения программы на отдельные сущности (процессы и треды(threads)) для обеспечивания параллельности выполнения. Зачем это нужно? Для ускорения работы. Ведь открывая какой-нибудь сайт вы не хотите ждать пока сервер последовательно откроет его всем, кто запросил его до вас. Вы хотите сразу, поэтому сервер выделяет отдельный процесс или поток для обработки вашего запроса.

Сначала немного про многопточность в PHP. PHP не многопоточный язык, PHP не умеет работать с тредами. Однако мы можем использовать системные вызовы операционной системы для создания процессов. Это как если бы мы просто запускали PHP-CLI несколько раз. Основная команда pcntl_fork разделяет выполнение программы на 2 части: родительскую и дочернюю, при этом эта команда вернет идентификатор процесса. Если вернулся -1, значит произошла ошибка, если 0, значит мы в дочернем потоке, если число - значит в родительском.

$pid = pcntl_fork();
if ($pid == -1) {
     die('Произошла ошибка');
} else if ($pid) {
     // Мы в родительском потоке
     pcntl_wait($status); //Ждем выполнения потомка
} else {
     // Мы в потоке потомке
     // Делаем что-нибудь
}

В этом примере мы разделили программу на 2 части. В родительском процессе мы ожидаем завершения дочернего, чтобы тот доложил об успешном завершении. В противном случае он останется висеть в системе, как процесс-зомби. А если мы хотим не 2 потока, а больше? Тогда вызываем pcntl_fork несколько раз.

Приведу пример, как можно использовать pcntl_fork для "демонизации" процесса. Демон (daemon) - процесс выполняющийся в фоновом режиме. Это бывает очень удобно для программ, которые выполняются долгое время и не требуют прямого общения с пользователем. В Windows службы - аналог демонов в *nix системах. Итак, у вас есть программа на PHP, выполняющаяся в командной строке и вы хотите, чтобы она работала в фоне. Конечно, вы всегда можете сделать так:

nohup php script.php &

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

//Demonization
$child_pid = pcntl_fork();
// Если мы получили дочерний id, 
// то мы в родительском потоке
if ($child_pid) {
    exit;
}
//Здесь мы уже в потомке, а родитель был закрыл
posix_setsid();

Таким образом мы получим независимо выполняющуюся программу. Завершить ее можно командой kill pid, где pid - идентификатор процесса. Тот самый, который возвращается в родительский поток и представляет собой целое неотрицательное число, уникальное в системе.

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

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

Данные плагина:

• название: blockUI v2
• размер: 15,6 кб без сжатия
• сайт плагина, скачать, демо

На сайте разработчика он выглядит так:

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

$.blockUI.defaults.css.border = '0px'; //убираем серую границу
$.blockUI.defaults.fadeIn = 100;  //ускоряем появление
$.blockUI.defaults.fadeOut = 100; //и исчезновение
$.blockUI.defaults.css.left = '40%'; //окно будет в центре

Этот код нужно вставить в страницу после подключения плагина. Параметр left:40% зависит от ширины окна, в моем случае оно 275 пикселей.

Что же сделать, чтобы окно выглядело как в Windows? Я конечно не мастер верстки, но результат мне вполне подходит. Сначала делаем макет окна и даем ему стили.

<div id="modal_dialog" style="display:none; cursor: default" class="dialog">
  <div class="dialog_title_bar">
    <div class="dialog_caption">www.charnad.com</div>
    <div class="rotes_kreuz"></div>
  </div>
   <div class="dialog_pane">
    <div>Наше модальное окошко</div>
    <div style="margin-top: 10px;">
     <form action="" method="POST">
       <input type="button" id="yes" value="Да" class="dialog_button"/>
       <input type="button" id="no" value="Нет" class="close_dialog dialog_button" />
     </form>
    </div>
 </div>
</div>

Почему display: none? Потому что плагин автоматически переключит видимость. Теперь CSS:

.dialog {
    cursor: default;
    border: 1px solid #000000;
}
 
.dialog form {
    margin: 0px;
}
 
/* Контейнер с заголовком */
.dialog .dialog_title_bar {
    height: 17px;
    padding: 1px;
    background-image: url(dialog-caption-bg.png) ;
}
 
/* Стиль текста заголовка */
.dialog .dialog_title_bar .dialog_caption {
    color: black;
    font-family: sans-serif;
    font-size: 9pt;
    text-align: left;
    padding-left: 5px;
    padding-top: 1px;
}
 
/* Панель диалога */
.dialog .dialog_pane {
    background: buttonface;
    text-align: center;
    padding-left: 10%;
    padding-right: 10%;
    padding-top: 10px;
    padding-bottom: 10px;
}
 
/* Кнопки диалога */
.dialog .dialog_button {
    width: 80px;
    height: 25px;
}
 
/* Красный крест, закрывающий окно */
.dialog .rotes_kreuz {
    background-image: url(rotes_kreuz.png);
    width: 28px;
    height: 15px;
    position: absolute;
    right: 3px;
    top: 3px;
    float: right;
    display: block;
    cursor: pointer;
}

Пути к картинкам, конечно же, поставьте свои. Сами картинки можно взять: фон заголовка, крест.

Теперь Javascript, чтобы все у нас прыгало и бегало.

$(document).ready(function() {
    //По этим кнопкам модальное окно закрывается
    $('.rotes_kreuz, .close_dialog').click(function() {
        $.unblockUI();
        return false;
    });
 
    //Эта кнопка будет вызывать наше окно
    $('#show_modal').click(function() {
        $.blockUI({message: $('#modal_dialog'), css: {width: '275px'}});
    });
 
    //По кнопке "Да" будет отправляться форма 
    $('#modal_dialog #yes').click(function() {
        $('#modal_dialog form').submit();
    });
});

Можно скачать:[filebase:file:file=3:tpl=simple] или посмотреть прямо здесь.

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

Если у вас ошибка "Unable to open database file" и при этом база читается, даже если вы дали права файлу БД 0777, то вам еще надо дать права на запись папке, в которой лежит файл. Дело в том, что при открытии транзакции пишется файл dbfilename-journal. Так же под Windows эта проблема может означать наличие кириллических символов в пути к базе.

Если вы по привычке написали ON DUPLICATE KEY UPDATE ..., и не понимаете в чем ошибка - обратитесь к официальному мануалу и просто измените INSERT на REPLACE, а "ON DUPLICATE..." сотрите.

Такая ошибка возникла у меня после перехода на PHP 5.3. Решение я нашел на http://stackoverflow.com, можете там посмотреть, чтобы узнать про эту ошибку более подробно. Выглядит она вот так:

Warning: PDO::__construct() [pdo.--construct]: [2002] Invalid argument (trying to connect 
via unix://) in /home/blah-blah-blah.php on line 9
 
Fatal error: Uncaught exception 'PDOException' with message 'SQLSTATE[HY000] [2002]
Invalid argument' in /home/blah-blah-blah.php:9 Stack trace: #0
/home/blah-blah-blah.php(9): PDO->__construct('mysql:host=localhost;dbname=db', 'USER', 
'PASSWORD') #1 {main} thrown in /home/blah-blah-blah.php on line 9

Решается она так: вместо localhost, при написании DSN для PDO пишите 127.0.0.1. А так же стоит указать путь к сокету MySQL в php.ini: pdo_mysql.default_socket=/var/run/mysqld/mysql.sock

Не так давно я купил себе зеркалку Nikon D60. Я достаточно долго щелкал на китовый объектив и, естественно, захотел новых игрушек. Китовый объектив я отдал хозяину, а себе купил кит от D90 Nikkor 18-105mm f/3,5-5.6, а чуть позже Гелиос-81Н 50мм f/2. Сейчас я коротенько расскажу про Гелиос.

Все получилось относительно быстро. Я нашел статью в интернете про то, что советская оптика от фотоаппаратов Киев 17,19,20 имеет байонет Н. А тот в свою очередь был скопирован с никоновского байонета, и поэтому они совместимы без переходников. Это же просто находка для никониста! Из всех объективов с таким байонетом наиболее доступным, и наиболее мне интересным был как раз 81й. Мой экземплярчик я нашел на Ebay. Продавец оказался из Ростова, и за несколько дней мы договорились, что за ~23$ я получаю его себе. Теперь мой фотоаппаратик выглядит вот так:

Немножко инфы про объектив. Выпускается в нескольких вариантах, если вы хотите поставить его на камеру Nikon - ищите с маркировкой Н. 81 просто и 81-Автомат не подойдут. Почти полным аналогом является Арсат-81Н, разница в чернении лепестков диафрагмы и просветлении. По слухам на Арсатах чернение лепестков осыпается - будьте внимательны. Объектив, естественно, полностью ручной. Диафрагма выставляется в пределах от 2 до 22 на объективе, наведение на резкость производится фокусировочным кольцом. Выдержку и ISO выставлять надо в камере в режиме M. Насколько мне известно, автоматически оценивать экспозицию сможет только D200, но если у вас есть деньги на D200 - наверняка, есть деньги и на современный объектив. Угол поля зрения 45°, разрешение (центр/край) - 40/20 лин/мм. Опять же по памяти этот объектив один из самых лучших по разрешающей способности.

Поначалу, конечно, тяжко все выставлять ручками, привык, понимаешь, к автоматике. Но теперь получаю несравнимое удовольствие от управления всем процессом. Ну и, конечно куда без фоточек. Пока их мало, но я буду выкладывать по мере появления более-менее достойных. Моя первая модель - киска по имени Ириска.

Мне нужно было получать строку из файла по порядковому номеру. То есть первую, десятую, 390815-ую, и т.д. Сначала мне хватало цикла fgets, который прокручивал до нужной строки. На строке 500000 такой способ у меня занимал уже почти минуту, что явно плохо. Stream_get_line был совем не быстрее, а даже медленнее процентов на 30.

Первый из костылей, пришедших мне в голову был fseek до значения в 500000 строк (посчитал байты), а оттуда уже крутил fgets. Но так как у меня идет обработка до 100 тысяч строк в сутки, то через пару дней опять пришлось высчитывать смещение для fseek. Опять же, требовался другой выход. И я его таки нашел.

function getFileLine($file, $line) {
    return trim(exec("head -n $line $file | tail -n 1"));
}

Head берет N первых строк файла, tail N последних. Все гениальное просто. 1 миллионная строка берется из файла за 1.027 сек, 40 миллионная - 30 секунд, что очевидно быстрее прокручивания fgets. (Конечно, если не прыгать fseek до 40 миллионной записи и считывать 40000001-ую)

Конечно, решение ограничено *nix системами, но т.к. моя система и без того использует pcntl_fork, она уже была привязана к никсам, так что хуже мне не стало.

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

CREATE TEMPORARY TABLE ids (VALUE INT, url VARCHAR(255));
INSERT INTO ids VALUES 
    (0, 'http://url1.ru'),
    (0, 'http://url2.ru'),
    (0, 'http://url3.ru');
UPDATE blogs, ids SET my_value = ids.VALUE WHERE blogs.url = ids.url;

Поясню. Допустим, мне понадобилось обновить некое значение в таблице в соответствии с URL. Скажем, статистику интернет-магазинов. Я создал временную таблицу из тех значений, по котороым будет вестись поиск, и значений, которые я буду вставлять в нужную мне таблицу. Дальше, идет INSERT сразу нескольких строк. Его очень просто собирать в цикле из массива. Например вот так:

$elements = array();
foreach ($aray as $url => $value) {
    $elements[] = '('.$db->escape($value).', '.$db->escape($url).')';
}
$insert_string = implode(',', $elements);

После чего, собственно апдейт со вставкой. Временная таблица исчезнет после окончания сессии БД. На то она и временная.