XGM Forum - Создание MUI без использования ретурн бага

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

Как вам должно быть известно на данный момент для создания стэка объектов, мы привыкли называть это SCV хотя это вовсе не так, кеш это хеш таблица по которой движок варкравта осуществяет поиск каждый раз при обращении к нему, чем больше данных сохранено тем больше времени это займёт.

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

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

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

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

Как пример такого выделения данных я могу предложить код выделения ячейки от SDARS.

Код:

//                                                                                               //
function SDARS_New takes integer Offset returns integer                                          //
    local integer OffS_I_1 = Offset                                                              //
    local integer Slot_I_1 = 0                                                                   //
    local integer Valu_I_1 = 256                                                                 //
    //                                                                                           //
    if Offset > 31 then                                                                          //
        set OffS_I_1 = 31                                                                        //
    endif                                                                                        //
    //                                                                                           //
    if Offset < 0 then                                                                           //
        set OffS_I_1 = 0                                                                         //
    endif                                                                                        //
    //                                                                                           //
    set Slot_I_1 = 256*OffS_I_1                                                                  //
    set Valu_I_1 = Slot_I_1 + 255                                                                //
    //                                                                                           //
    if udg_LH_LogicUse[OffS_I_1] == 0 and OffS_I_1 != 0 then                                     //
        set udg_LH_LogicUse[OffS_I_1] = Slot_I_1                                                 //
    else                                                                                         //
        set Slot_I_1 = udg_LH_LogicUse[OffS_I_1]                                                 //
    endif                                                                                        //
    //                                                                                           //
    loop                                                                                         //
        exitwhen udg_LH_Events[Slot_I_1] == null or Slot_I_1 > Valu_I_1                          //
        set Slot_I_1 = Slot_I_1 + 1                                                              //
    endloop                                                                                      //
    //                                                                                           //
    set udg_LH_LogicUse[OffS_I_1] = Slot_I_1 + 1                                                 //
    //                                                                                           //
    if udg_LH_LogicUse[OffS_I_1] > Valu_I_1 then                                                 //
        set udg_LH_LogicUse[OffS_I_1] = 256*OffS_I_1                                             //
    endif                                                                                        //
    //                                                                                           //
    return Slot_I_1                                                                              //
endfunction                                                                                      //
//                                                                                               //

Структура что получается при использовании этого механизма выделения это двумерный массив 32*256

первый подмассив имеет границы 0-255 второй 256-511

смещение по 256 определяется так называемым OffSet значением что сдвигает область по объёму массива, но это не мешает вам изменить размерность и получить например
64 офсета по 128 значений или 16 по 512

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

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

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

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

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

Итак о перменных что были задействованы внутри функции.

Код:

local integer OffS_I_1 = Offset определяет оффсет
    local integer Slot_I_1 = 0 изначально определяло шаг оффсета для создания 3d массива но после я отказался отэтой идеи, такчто данная переменная не определяет ничего изначально, но будет использована в дальшейшем.
    local integer Valu_I_1 = 256 Определяет размер оффсета

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

Код:

set Slot_I_1 = 256*OffS_I_1          определяет нижнюю границу оффсета
    set Valu_I_1 = Slot_I_1 + 255        определяет верхнюю границу оффсета

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

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

    if udg_LH_LogicUse[OffS_I_1] == 0 and OffS_I_1 != 0 then                                   
        set udg_LH_LogicUse[OffS_I_1] = Slot_I_1                                                
    else                                                                                         
        set Slot_I_1 = udg_LH_LogicUse[OffS_I_1]                                                 
    endif

После всех изысканий в пределах логики, а вернее после обработки входных параметров происходят некоторые проверки, а именно

Код:

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

    loop
        exitwhen udg_LH_Events[Slot_I_1] == null or Slot_I_1 > Valu_I_1
        set Slot_I_1 = Slot_I_1 + 1
    endloop

Так как для логического числа нужен первый свободный слотегоимеетсмысл сохранить сразу же не думая долго, и не трогать номер слота для выделения вовсе, если этого не делать можно будет убить массив, так-же если передвинуть ячейку вручную вне зону текущего оффсета
    set udg_LH_LogicUse[OffS_I_1] = Slot_I_1 + 1

вот и всё мы получили необходимое число в массиве остались лишь формальности, а именнопроверка на соответствие логического числа тому что нам нужно, можновынести это действие в начало, но тогда вы лишите себя возможности контролировать массив вручную, как бы это не звучало вы можете администрировать массивы в течении игры если умеете это делать, модифицировать содержимое ячеек и так далее, что при использовании кеша затруднительно так как вам надо знать два ключа.
    if udg_LH_LogicUse[OffS_I_1] > Valu_I_1 then
        set udg_LH_LogicUse[OffS_I_1] = 256*OffS_I_1
    endif
Воти все, если логическое число выпало за пределы оффсета сбрасываем его на нижнюю границу получая её из количества элементов в оффсете.
Да, количество элементов сохранено в нескольких местах, так что вам при изменении механизма придётся проверить весь код, хотя это не составит для вас особого труда особенно если вы поняли что я хотел донести до вас в этом краткой обзоре возможности создания MUI конструкций без использования ретурн бага.

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

ну и конечно нам стоит вернуть заветное число в кодгде мы его решили использовать

    return Slot_I_1

итак часть два, получение информации измассивов....

Код:

//                                                                                               //
function SDARS_Get takes integer OffSet returns integer                                          //
    local integer Slot_I_1 = 256*OffSet                                                          //
    local trigger Trig_T_1 = GetTriggeringTrigger()                                              //
    //                                                                                           //
    loop                                                                                         //
        exitwhen udg_LH_Events[Slot_I_1] == Trig_T_1 or Slot_I_1 >= 256*OffSet+255               //
        set Slot_I_1 = Slot_I_1 + 1                                                              //
    endloop                                                                                      //
    //                                                                                           //
    set Trig_T_1 = null                                                                          //
    return Slot_I_1                                                                              //
endfunction                                                                                      //
//                                                                                               //

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

Ну тут сложностей увы никаких нет и долго я рассказывать не буду,

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

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

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

1) выделеный объект всегда будет занят, функций отмотки просто нет, если слот в массиве выделен он будет занят в любом случае, хотя функцию отмотки можно собрать, она будет опасна по определению таккак может отмотать не то что надо.
2) после получения объекта не обязательно что он будет удалён, но обязательно что онвсё еще существует, это вторая функция SDARS , как вам должно быть известно RS это система что прекомпилировала данные перед обработкой, тут так-же, вскоре а вернее если будет времяяпокажу как это работает, хотя это будет просто кошмарно смотреться
3) нци последнее правило, удалёный объект больше несуществует его ячейку нельзя использовать но можно занять вновь.

кстати о очищении массивов, тут тоже есть функция...

Код:

//                                                                                               //
function SDARS_Drop takes integer Slot_I_1 returns nothing                                       //
    //                                                                                           //
    if udg_LH_Events  [Slot_I_1] != null then                                                    //
        call TriggerRemoveAction(udg_LH_Events[Slot_I_1],udg_LH_Actions[Slot_I_1])               //
        call DestroyTrigger(udg_LH_Events[Slot_I_1])                                             //
        set udg_LH_Events  [Slot_I_1] = null                                                     //
        set udg_LH_Actions [Slot_I_1] = null                                                     //
    endif                                                                                        //
    //                                                                                           //
    if udg_LH_Effects [Slot_I_1] != null then                                                    //
        call DestroyEffect(udg_LH_Effects[Slot_I_1])                                             //
        set udg_LH_Effects [Slot_I_1] = null                                                     //
    endif                                                                                        //
    //                                                                                           //
    set udg_LH_Trees   [Slot_I_1] = null                                                         //
    set udg_LH_Logic   [Slot_I_1] = false                                                        //
    set udg_LH_Units   [Slot_I_1] = null                                                         //
endfunction                                                                                      //
//                                                                                               //
//                                                                                               //
function SDARS_Start takes integer Slot , real Time , code Func returns nothing                  //
    set udg_LH_Events[Slot] = CreateTrigger()                                                    //
    set udg_LH_Actions[Slot]= TriggerAddAction(udg_LH_Events [Slot],Func)                        //
    call TriggerRegisterTimerEvent(udg_LH_Events [Slot],Time,true)                               //
endfunction                                                                                      //
//                                                                                               //

Функция очищения никогда не осуществляется автоматически и не перематывает какие либо числа, так как ошибочный вызов её 2-3 раза подряд мог убить весь массив.

Ну и основная функция это убийство указаной ячейки во всех доступных массивах, если вы будете использовать 3d массив 2*32*128, то надо будет убивать сразу по две ячейки, хотя это неважно.

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

ну а теперь краткая инструкция по 3д массиву.
Пишу как пример, работать это не будет, просто посмотрите алгоритм

Код:

function SDARS_Alloc takes integer X, integer Y, integer Z returns integer
local integer AllocByZ = Z
local integer AllocByX = X
local integer AllocByY = Y
local integer UP       = 0
local integer DAWN     = 0
local integer FINAL    = 0

if Z > 1 then
set Z = 1
elseif Z < 0 then
set Z = 0
endif

if X > 31 then
set X = 31
elseif X < 0 then
set X = 0
endif

if Y > 127 then
set Y = 127
elseif Y < 0 then
set Y = 0
endif

set DAWN  = 128*X
set UP    = 128*X + 127 
set FINAL = GetRandomInt(DAWN,UP)+((8192/2)*Z)

return FINAL

endfunction

Как вы можете видеть нет ничего сложно в выделении 2х 3х и даже 4х мерных массивов, можно сделать неограниченое число измерений и использовать их.

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

NETRAT offline Опыт: 83,712 Активность:	теперь мне понятно, надо более внимательно вчитаться в код я уже не раз обьяснял почему в общем случае рандом в таких системах - полный бред =)
11.11.2006, 14:59	#4 +0/−0 Профиль \| Приват \| Поиск \| Цитата \| IP: Записан

remal нечто offline Опыт: 2,087 Активность:	используйте кучу и будет вас счатье. перебор сосёт.
20.11.2006, 02:49	#8 +0/−0 Профиль \| Приват \| Поиск \| Цитата \| IP: Записан

DioD offline Опыт: 45,134 Активность:	вот ты мне объясни как в кеше вар ищёт данные? не перебор хочешь сказать?
20.11.2006, 12:35	#9 +0/−0 Профиль \| Приват \| Поиск \| Цитата \| IP: Записан

Опции темы	Поиск в этой теме
Версия для печати	Поиск в этой теме: Расширенный поиск