Архив для категории: Николай Зверев

Занимаясь отладкой процедур, связанных с обработкой сообщений, постоянно приходится делать сопоставление между кодом сообщения и его строковым наименованием. Ну, к примеру, «прилетает» код 6 — это WM_ACTIVATE. Или сложнее: код 274 (0x0112) = WM_SYSCOMMAND.

(Кстати, мне впервые в жизни пришло в голову попробовать их использовать.)

  case Msg of
    WM_NULL: Result := 'WM_NULL';
    WM_CREATE: Result := 'WM_CREATE';
    ...
    WM_APP: Result := 'WM_APP';
  end;

  {$EXTERNALSYM WM_NULL}
  WM_NULL             = $0000;
  {$EXTERNALSYM WM_CREATE}
  WM_CREATE           = $0001;
  ...
  {$EXTERNALSYM WM_APP}
  WM_APP = $8000;

Макрос готов, теперь просто жамкаем в «Playback Macro»
пока не достигнем нужного результата.

Читать на сайте автора.

У котнролов в VCL есть свойство Visible, которое как называется, за то и отвечает. Если Visible = False, то контрол скрыт и пользователь его не увидит. Если Visible = True, то есть вероятность, что пользователь его увидит.

А есть ещё два метода – Hide и Show, которые взаимодействуют со свойством Visible.

А теперь вопрос: как же правильно скрывать/отображать контрол?

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

В большинстве случаев ответ напрашивается сам собой: используем Visible, т.к. это способствует единообразию. Например, потому что есть свойство Enabled, для которого нету методов типа Enable/Disable. У экшенов (TAction) есть Visible, но нет Show/Hide. И ещё такой момент, сравните:

LabelSomeInfo.Visible := SomeCondition;

и

if SomeCondition then
  LabelSomeInfo.Show
else
  LabelSomeInfo.Hide;

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

Ещё можно порассуждать так (на интуитивном уровне, ещё не заглядывая в исходники или справку). Visible – это свойство, которое задаёт (и показывает) состояние контрола на текущий момент времени. Show/Hide – это методы, они призваны изменить состояние контрола, но не факт, что это произойдёт одномоментно, и не факт, что это действие не приведёт к какому-то побочному эффекту. Поэтому (как бы) безопаснее использовать Visible.

Теперь самое время заглянуть в исходники VCL. Hide просто скрывает контрол (устанавливая Visible в False). А вот Show не только меняет Visible, но делает кое-что ещё. А именно – вызывает виртуальный метод ShowControl у родительского контрола (если такой определён). А это и есть тот самый побочный эффект, о котором можно догадаться на интуитивном уровне. На практике, в самой VCL, я нашёл только одно место, где это можно использовать – компонент TPageControl. Когда мы вызываем Show для контрола, расположенного на одной из вкладок PageControl’а, происходит активация той вкладки (TabSheet), на которой этот контрол расположен. Более того, если вложить несколько PageControl’ов друг-в-вдруга, то активация вкладок произойдёт по цепочке от контрола вверх до самой формы.

Т.е. вывод делаем такой: если просто нужно задать состояние для контрола (в большинстве случаев именно это и нужно), то используем Visible. Если нужно акцентировать внимание пользователя на контрол, то используем Show (и ещё, после этого, можно вызвать SetFocus для полей ввода). Зачем нужен Hide – не знаю, видимо он заводился на “автомате”, в противовес Show. Ещё странно, что эти методы не виртуальные…

В общем, это надо знать и уметь применять.

А за примерами, где это может быть применимо, далеко ходить не надо. В самой IDE Delphi: нажимаем F6, набираем “editor font”, жамкаем Enter – открывается окно с настройками IDE, осуществляется переход к вкладке Editor Options Display и устанавливается фокус ввода на комбобокс для выбора шрифта. (Уверен, что это сделано парой вызов Show + SetFocus для самого комбобокса.)

Ещё пример (уже из моей практики). На форме есть обязательное для ввода поле. Пользователь его не заполнил и переключился на другую вкладку, затем нажимает OK. Я вижу, что поле не заполнено, и просто вызываю пару методов Show + SetFocus (не задумываясь, надо ли активировать вкладку, на какой вкладке это поле и т.п.). После этого можно показать сообщение пользователю (мол заполни поле) или даже не показывать, а сделать Beep – фокус уже будет где надо, и пользователь поймёт, что от него требуется.

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

Читать на сайте автора.

Ура! Конкурс завершён, поздравляю победителей с победой!

Обещанный нехус 7 в оригинальной футболке приехал прямо ко мне домой курьерской доставкой. Достойный приз требует достойного завершения, а именно – размещения конкурсной программы в Google Play.

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

Итак, прежде чем разместить приложение в Google Play, его необходимо специальным образом подготовить. Это самое неочевидное (для меня) действие, хотя делается всё очень просто.

Открываем проект в Delphi, затем выбираем Project Options –> Provisioning. Далее выбираем цель Target: Release configuration — Android platform и тип сборки Build Type: Android Store. Далее жамкаем кнопку New Keystore… и следуем указаниям мастера (придумываем имя для файла, пароли и алиасы). Мастер сгенерит цифровую подпись, без которой Google Play не примет apk-файл, ругнувшись на то, что “Архив APK-файла не оптимизирован”. У меня выглядит это так:

Затем необходимо выбрать (т.е. активировать в Project Manager’е) необходимую конфигурацию сборки. Это делается в три двойных клика по выделенным на картинке ниже строкам:

Если не выбрать Application Store, то Google Play ругнётся, мол необходимо удалить отладочную информацию из APK-файла.

Теперь делаем Project Build XXX и сразу Project Deploy libXXX.so (где XXX – это имя проекта). После этого, APK-файл готов для размещения в Google Play и находится в каталоге …AndroidReleaseXXXbin.

Следующий шаг – это регистрация аккаунта разработчика в Google Play. Для этого надо перейти в Google Play Developer Console. И теперь самое неприятное – заплатить 25 USD. Честно говоря, я немного поколебался, мол “а надо ли оно мне?”, но потом подумал, что это не такая уж и большая сумма, может быть она себя и не окупит, но по бюджету не ударит.

Ну и далее всё просто, я особо описывать не будут. Потребуют: подготовленный APK-файл, иконку приложения размером 512х512 пикселей и 2 скриншота с реального устройства.

После всех этих процедур мне пообещали, что для скачивания приложение будет доступно через несколько часов. В общем, как только – так сразу, а пока – ждём-с.

Ссылка для скачивания (в маркете искать по словам “nikolay zverev”).

Читать на сайте автора.

Эта заметка является продолжением предыдущих: Tap#1, Tap#2, Tap#3. И в ней я поговорю об анимации.

В моей будущей игре у персонажа будет два основных состояния. Назовём их “Открытый” и “Закрытый”. В первом состоянии внешний вид персонажа соответствует тому, который разработан в дизайнере и сохранён в переменной DesignPositions. Во втором, вид персонажа будет другой. Для робота я решил так: меняем цвет на серый, чуть-чуть уменьшаем общий размер, втягиваем ноги, руки и антенны, закрываем глаза.

Соответственно переход из состояния в состояние будет анимированным.

Делаю я следующим образом: сразу после создания фреймы, в методе SaveDesignPositions, произвожу необходимые трансформации и сохраняю положения и размеры объектов в переменную FClosedPositions. Вот так:

type
  TframeRobot = class(TNPC)
  private
    FClosedPositions: TDesignPositions;
  public
    procedure SaveDesignPositions; override;
//...
procedure TframeRobot.SaveDesignPositions;
  procedure SwitchToClose;
  const
    kBody = 9/10;
    kEye = 1/4;
    kAnt = 1/4;
    kHand = 5/6;
    kHand2 = 1/2;
    kLeg = 1/3;
  begin
    // HINT: мы смотрим роботу в лицо, поэтому левая рука - справа, правая - слева

    // уменьшаем Body
    Body.Position.X := Body.Position.X + Body.Width / 2 * (1 - kBody);
    Body.Width := Body.Width * kBody;
    Body.Position.Y := Body.Position.Y + Body.Height / 2 * (1 - kBody);
    Body.Height := Body.Height * kBody;
    // смещаем соединительные линии между телом и ногами
    LegLeftCon.Position.Y := LegLeftCon.Position.Y - LegLeftCon.Height * kBody;
    LegRightCon.Position.Y := LegRightCon.Position.Y - LegRightCon.Height * kBody;

    // уменьшаем Head
    Head.Position.X := Head.Position.X + Head.Width / 2 * (1 - kBody);
    Head.Width := Head.Width * kBody;
    Head.Position.Y := Head.Position.Y + Head.Height / 2 * (1 - kBody);
    Head.Height := Head.Height * kBody;

    // приближаем Head к Body
    HeadCenter.Position.Y := HeadCenter.Position.Y + Head.Height * (1 - kBody);

    // закрываем глазки
    EyeLeft.Position.Y := EyeLeft.Position.Y * kBody + EyeLeft.Height * kEye;
    EyeLeft.Height := EyeLeft.Height * kEye;
    EyeRight.Position.Y := EyeRight.Position.Y * kBody + EyeRight.Height * kEye;
    EyeRight.Height := EyeRight.Height * kEye;

    // уменьшаем и прячем антенны
    AntenaRight.Position.Y := AntenaRight.Position.Y * kBody + AntenaRight.Height * kBody;
    AntenaRight.Height := AntenaRight.Height * kBody * kAnt;
    AntenaRight.Position.Y := AntenaRight.Position.Y - AntenaRight.Height;

    AntenaLeft.Position.Y := AntenaLeft.Position.Y * kBody + AntenaLeft.Height * kBody;
    AntenaLeft.Height := AntenaLeft.Height * kBody * kAnt;
    AntenaLeft.Position.Y := AntenaLeft.Position.Y - AntenaLeft.Height;

    // прячем руки
    HandRightCenter.RotationAngle := 90;
    HandRightCenter.Position.X := HandRightCenter.Position.X + HandRight.Height * kHand;
    HandRightCenter.Position.Y := HandRightCenter.Position.Y + HandRight.Width * kHand2;

    HandLeftCenter.RotationAngle := -90;
    HandLeftCenter.Position.X := HandLeftCenter.Position.X - HandLeft.Height * kHand;
    HandLeftCenter.Position.Y := HandLeftCenter.Position.Y + HandLeft.Width * kHand2;

    // прячем ноги
    LegRightCenter.Position.Y := LegRightCenter.Position.Y - LegRight.Height * kLeg;
    LegLeftCenter.Position.Y := LegLeftCenter.Position.Y - LegLeft.Height * kLeg;
  end;
begin
  inherited;

  SwitchToClose;
  FClosedPositions := TDesignPositions.Create;
  SavePositionsTo(FClosedPositions);
end;

Здесь TframeRobot – это наш персонаж, про TNPC и SaveDesignPositions я писал в предыдущей заметке. Вот так выглядит наш робот до и после трансформации:

DesignPositions соответствуют картинке слева, ClosedPositions – картинке справа. Это начальное и конечное состояние в анимации. Сама анимация протекает во времени. Если взять начало времени за ноль, а конец – за единицу, то положение объекта легко рассчитать по формуле:  f(t) = a + (b – a) * t, где t – время от 0 до 1, а – начальная координата, b – конечная координата, f – искомая координата. В библиотеке FMX такая функция уже реализована и называется InterpolateSingle.

Вот так у меня выглядит процедура для изменения размеров и положений объектов робота:

procedure TframeRobot.ProcessOpenCloseAnimation(const AProgress: Single);
var
  BodyColor: TAlphaColor;
  i: Integer;
  CP, DP: TDesignPosition;
  AControl: TControl;
begin
  BodyColor := InterpolateColor($FF99CC00, TAlphaColors.Gray, AProgress);

  // цикл от 1, т.к. саму фрейму масштабировать не надо
  for i := 1 to DesignPositions.Count - 1 do
  begin
    AControl := Controls[i];
    CP := ClosedPositions.Items[i];
    DP := DesignPositions.Items[i];

    // цвет
    if (AControl is TShape) and (AControl <> EyeLeft) and (AControl <> EyeRight) then
      if TShape(AControl).Fill.Color <> TAlphaColorRec.Null then
        TShape(AControl).Fill.Color := BodyColor;

    // положение
    AControl.Position.X := InterpolateSingle(DP.Left, CP.Left, AProgress) * ScaleFactor;
    AControl.Position.Y := InterpolateSingle(DP.Top, CP.Top, AProgress) * ScaleFactor;

    // размер применяем ко всем, кроме "опорных" точек
    if Pos('Center', AControl.Name) = 0 then
    begin
      AControl.Width := InterpolateSingle(DP.Width, CP.Width, AProgress) * ScaleFactor;
      AControl.Height := InterpolateSingle(DP.Height, CP.Height, AProgress) * ScaleFactor;
    end;

    // поворот
    AControl.RotationAngle := InterpolateSingle(DP.RotationAngle, CP.RotationAngle, AProgress);
  end;
end;

(Про ScaleFactor я писал в предыдущей заметке.)

Как видите, ничего тут сложного нет.

Теперь создаём TFloatAnimation-объект, назовём его faOpenClose:

  object faOpenClose: TFloatAnimation
    Duration = 0.300000000000000000
    OnProcess = faOpenCloseProcess
    PropertyName = 'OpenCloseValue'
  end

Далее у фреймы:

type
  TframeRobot = class(TNPC)
  ..
    procedure faOpenCloseProcess(Sender: TObject);
  private
    FOpenCloseValue: Single;
    FClosed: Boolean;
  ..
  public
    property OpenCloseValue: Single read FOpenCloseValue write FOpenCloseValue;
  ..
procedure TframeRobot.faOpenCloseProcess(Sender: TObject);
begin
  ProcessOpenCloseAnimation(FOpenCloseValue);
end;

И осталось запустить анимацию в прямом:

procedure TframeRobot.CloseWithAnimation;
begin
  FClosed := True;
  faOpenClose.Stop;
  faOpenClose.StartValue := 0;
  faOpenClose.StopValue := 1;
  faOpenClose.Start;
end;

, либо обратном направлении:

procedure TframeRobot.OpenWithAnimation;
begin
  FClosed := False;
  faOpenClose.Stop;
  faOpenClose.StartValue := 1;
  faOpenClose.StopValue := 0;
  faOpenClose.Start;
end;

Ну и теперь, мы можем реализовать метод ScaleControls, который в прошлой заметке остался не реализованным. Выглядит он у меня так:

procedure TframeRobot.ScaleControls;
  procedure ScalePositions;
  begin
    // устанавливаем расположение контролов в зависимости от текущего состояния
    // (процедура анимации учтёт ScaleFactor)
    if FClosed then
      ProcessOpenCloseAnimation(1)
    else
      ProcessOpenCloseAnimation(0)
  end;

  procedure ScaleStrokeThickness;
  var
    i: Integer;
  begin
    for i := 1 to Length(Controls) - 1 do
      if Controls[i] is TShape then
        if TShape(Controls[i]).Stroke.Kind = TBrushKind.bkSolid then
          TShape(Controls[i]).Stroke.Thickness := 12 * ScaleFactor;
  end;

  procedure RecalcBodyRadius;
  begin
    Body.XRadius := (LegLeft.LocalRect.Width - LegLeft.Stroke.Thickness) / 2;
    Body.YRadius := Body.XRadius;
  end;

  procedure RecalcAntenaRadius;
  begin
    AntenaLeft.XRadius := (AntenaLeft.Width - AntenaLeft.Stroke.Thickness) / 2;
    AntenaLeft.YRadius := AntenaLeft.XRadius;
    AntenaRight.XRadius := AntenaLeft.XRadius;
    AntenaRight.YRadius := AntenaLeft.XRadius;
  end;

begin
  ScalePositions;
  ScaleStrokeThickness;
  RecalcBodyRadius;
  RecalcAntenaRadius;
end;

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

Читать на сайте автора.

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

На самом деле, я перепробовал несколько вариантов. Сначала даже пробовал в 3D – я подумал, что можно сделать что-то красивое-объёмное, потом поиграться с тенями и освещением… но это занимает очень много времени, а в результате, при большом количестве объектов, на Android-устройстве всё это подтормаживает.

В 2D я тоже пробовал по-разному… От растровых картинок отказался сразу. Потому что векторную графику можно и отмасштабировать без потери качества, и анимировать отдельные объекты труда не составит. От своего собственного объекта-наследника от TShape, в котором закодировать (хардкорно) всю прорисовку – тоже отказался, т.к. это довольно трудоёмко. В конце-концов решил, что пусть это будет набор из готовых Shape-компонентов, размещённых в отдельной фрейме. Это и проще, и нагляднее. (Спасибо разработчикам FM, что вспомнили про TFrame, т.к. в Delphi XE2 в FireMonkey фрейм не было.)

Дальше я нашёл в интернете картинку с зелёным роботом, и положил её на фрейму в обычный TImage. Картинку выбрал с высоким разрешением, чтобы легче было накладывать на неё объекты. Затем, через меню Tools Options… –> Form Designer, выключил выравнивание по сетке в дизайнере, сняв флажок Snap to grid.

Теперь начинаем формировать персонаж. Тут тоже всё просто. Кидаем поверх картинки TRectangle, подгоняем размер до пикселя. Создаём следующий объект, кидаем поверх картинки и т.д. Чтобы легче было подогнать, делаем объект полупрозрачным, задав в его свойствах Opacity = 0,5.

Т.к. я планирую объекты анимировать, т.е. двигать (меняя Position), крутить (меняя RotationAngle), сжимать-растягивать (меняя Width и Height), то я применил такую хитрость: объекты кидаются не на фрейму, а в промежуточный TRectangle (размером в одну точку). Это нужно чисто для удобства, чтобы координаты объекта рассчитывались не относительно фреймы, а относительно некоторой точки (в 3D для этих целей есть TDummy, аналога для 2D я не нашёл). На картинке из предыдущей заметки Вы можете увидеть объекты с именами RoboCenter, LegRightCenter и т.п. – это как раз и есть “опорные” для анимации точки.

Когда робот готов – фоновая картинка больше не нужна. (Но я удалять её не стал, а просто создал отдельную фрейму, на которую скопировал получившегося персонажа.) С этой новой фреймой и буду работать дальше.

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

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

Читать на сайте автора.