Новое меню и несколько туманные перспективы...

После очень долгого перерыва решил все же написать очередной пост. Поскольку за это время произошло довольно мн6ого событий в мире 3D, а многие так и довольно давно, но мой консерватизм вкупе с известными проблемами не давал возможности заняться новым вплотную...
Итак, БГЕ - все. Обновлять его не будут, из версии 2.8 он выпилен, это и так многие знают. Остается, правда, UPBGE, да время от времени всплывают слухи, что в Блендер все же вставят что-то вроде игрового движка, но что это будет за новый "БГЕ" и будет ли он вообще - неясно.
Версия 2.8 уверенно развивается, 2.83 уже почему-то обозвали 2.9 - во всяком случае, при распаковке 2.9 в названии присутствует.
Следовательно, рано или поздно, но пришлось бы осваивать 2.8, с его новым интерфейсом, и новыми фишками, в которых автор этих строк пока не слишком (он и в 2.7 не слишком-то - имеется в виду рендер и использование всех возможностей программы).
За это время я принялся изучать Cycles и делать по урокам материалы (уроки Striver), а также читать, смотреть видеоуроки (которые перед этим скачивал ночью, по причине огромного трафика), и вообще пытаться больше понять 3D, его терминологию и возможности. И не только Блендер, но и Юнити и Анрил Энжин (с последним все же сильно не очень, потому как в Юнити куда как больше справочных материалов).
Но бросать свой бге-ешный проект не хотелось и работа продолжилась. Итогом стал очередной погром, который, похоже, выльется в переход на UPBGE  с новым, еще большим погромом. Все дело в том, что два с половиной года, отнятые у меня катарактой и сопутствующими ей "прелестями" привели к тому, что многое из того, что делалось, забылось, и просто-напросто устарело. Фактически проект будет делаться заново, правда в нем будут использоваться огромные куски кода, которые не забыты и могут быть использованы. Помимо этого необходимо освоить PBR-материалы, рендер EEVEE, заодно до кучи продолжить изучение Юнити и Cycles, а также заняться еще кое-чем, что непосредственно к 3D отношения не имеет и здесь поэтому перечисляться не будет. Как говорил Ильич: "Учиться, учиться и еще раз учиться" (Я помню этот лозунг, сложенный из вырезанных из пенопласта букв, прикленных к стене нашего школьного класса под потолком рядом с портретом вождя мирового пролетариата).
Некоторое время назад я занялся меню игры, которое было собрано наспех и кое-как. Сделать его удалось, хотя и было в итоге завалено дело с загрузкой объектов, но меню тут ни при чем, все дело было в загрузочном скрипте игровой сцены, которое было чрезмерно раздуто и усложнено. Само же меню прекрасно работает (хотя и не доделано по причине провала с загрузкой, но, судя по распечаткам консоли, все что нужно, оно делало, а редактор миссий и кампаний делать пока бессмысленно).
Меню позволяет переключаться между разделами, выбирать одиночную миссию, переходить на игровую сцену (где все и рвется), вызывает справку, меняет язык интерфейса. В общем, все работает, кроме редактора миссий и кампаний.
Ниже приводится текст скрипта меню, для которого используется логика лишь на одном объекте стартовой сцены-меню, причем логических кирпичей используется только 4. В ранней версии их было втрое больше, плюс имелась логика на других объектах. Само меню перед стартом подгружает бленд с нужными объектами, изначально в сцене только камера с логикой и плейн со стартовым черным фоном.
Итак, скрипт:

import bge
import sys
import os
import json
scene = bge.logic.getCurrentScene()

#Обьявление объекта сцены курсора
CursorMenu = scene.objects["CursorMenu"]

#Загрузка элементов меню из папки с компонентами
bge.logic.LibLoad("//Menu/Blend_Folder/Menu_Component.blend", 'Scene', load_actions = True)
   
pathJSON = ""
pathFon = ""
bge.logic.globalDict["bglText"] = ""
bge.logic.globalDict["DayNight"] = 1.3
bge.logic.globalDict["textGame"] = "Rus"

#Далее идет блок клавиатурных команд
keyboard = bge.logic.keyboard
JUST_ACTIVATED = bge.logic.KX_INPUT_JUST_ACTIVATED
JUST_RELEASED = bge.logic.KX_INPUT_JUST_RELEASED
INPUT_ACTIVE = bge.logic.KX_INPUT_ACTIVE

cont = bge.logic.getCurrentController()
own = cont.owner

#Сенсоры для управления меню
mouseMotion = cont.sensors["MouseMotion"]
mouseClick = cont.sensors["MouseClick"]

#Звуковой актуатор щелчка по кнопке
audioTemp = cont.actuators['SoundClick']

#Стартовые значения для меню - миссия по умолчанию
bge.logic.globalDict['currentMission'] = "MiG-23MF_vs_F-5E"
bge.logic.globalDict["dictUnit"] = []
bge.logic.globalDict["listUnit"] = []
bge.logic.globalDict["listEnemy"] = [ [[],[]], [[],[]] ]

scaleButtonStandart = {
                       "ButtonShort":[5.775, 1.5, 0.0],
                       "ButtonLong":[8.49, 1.5, 0.0],
                       "ButtonExit":[1.5, 1.5, 0.0],
                       "ButtonUp":[1.5, 1.5, 0.0],
                       "ButtonDown":[1.5, 1.5, 0.0],
                       #"ButtonUniversal":[1.5, 1.5, 0.0],
                       #"ButtonBig":[5.775, 4.12, 0.0],
                       "ButtonForward":[1.5, 1.5, 0.0],
                       "ButtonBack":[1.5, 1.5, 0.0]
                       }
 
#Создание проперти объекта для положения курсора
if "cursorPos" not in own:
    own["cursorPos"] = {"addSceneGame":0,
                        "tempX":0.0,
                        "tempY":0.0,
                        "language":"",
                        "listButton":[],
                        "animationButton":0,
                        "indexButton":"",
                        "oldPathFon":"",
                        "newPathFon":"",
                        "TimerColor":0,
                        "AlphaColor":0.0,
                        "newPatchMenu":"//Menu/JSON_Folder/Menu_Start.json",
                        "oldPatchMenu":"",
                        "PathFon":"",
                        "PathFonMonitor":"",
                        "limitXscroll":0,
                        "limitYscroll":0,
                        "valueButtonCoord":[0.0, 0.0, 0.0],
                        "pathButtonTXT":{},
                        "pathNameMission":{}
                        }

#Функция создания файла json с путями к файлам всего проекта
def startPath():
    cont = bge.logic.getCurrentController()
    scene = bge.logic.getCurrentScene()
    own = cont.owner
 
    #Создаем переменные - списки путей блендов и json плюс пустую строку для путей
    k = ""
    endStrPy = ""
    pathGeneral = []
    pathBlend = []
    pathJSON = []
    pathPy = []
 
    #Циклом перебираем файлы, директории и папки, создаем и сшиваем строки в пути
    for d, dirs, files in os.walk(bge.logic.expandPath("//")):
        for f in files:
         
            k = os.path.join(d,f)
         
            if ".blend1" in k:
                os.remove(k)
         
            #Питон-файлы добавляем в sys.path, остальные в список путей
            if ".py" not in k:
                k = k.split("BlendSim_2.1")[1]
                k = k.replace("\\", "/")
                if ".blend" in k:
                    if ".blend1" not in k:
                        pathGeneral.append("/"+k)
                if ".json" in k:
                    pathGeneral.append("/"+k)
         
            elif ".py" in k:
                if "__pycache__" not in k:
                    endStrPy = k.split("\\")[-1]
                    k = k.replace(endStrPy, "")
                    sys.path.append(k)
                    pathPy.append(k)
                 
    #Открываем файл json  с путями (если его нет, то он создается) и сбрасываем туда список путей
    with open(bge.logic.expandPath('//NodePath.json'), 'w') as NODEPATH:
        json.dump(pathGeneral, NODEPATH)

#Функция работы курсора меню и всех его компонентов - УЗЛОВАЯ ФУНКЦИЯ для  GeneratorMenuObj, buttonJob и on_click
def cursorPos():
    cont = bge.logic.getCurrentController()
    own = cont.owner
 
    #Сработка псевдоанимации при старте игры
    if mouseMotion.positive:
        if own["cursorPos"]["addSceneGame"] == 0:
            #Работет таймер
            if own["cursorPos"]["TimerColor"] < 600:
                own["cursorPos"]["TimerColor"] += 1
         
                #Сначала меняем меш курсора на логотип и медленно увеличиваем его "видимость"
                if own["cursorPos"]["TimerColor"] == 1:
                    CursorMenu.replaceMesh("Logo", True, False)
                    CursorMenu.color = [1.0, 1.0, 1.0, 0.0]
         
                if 1 < own["cursorPos"]["TimerColor"] < 200:
                    if own["cursorPos"]["AlphaColor"] < 1.0:
                        own["cursorPos"]["AlphaColor"] += 0.005
                 
                #Затем логотип медленно истаивает - увеличивается прозрачность
                if 200 < own["cursorPos"]["TimerColor"] < 400:
                    if own["cursorPos"]["AlphaColor"] > 0.0:
                        own["cursorPos"]["AlphaColor"] -= 0.005
         
                #Теперь меняем меш логотипа обратно на меш курсора
                if own["cursorPos"]["TimerColor"] == 401:
                    CursorMenu.replaceMesh("CursorMenu", True, False)
             
                #И заставляем курсор постепенно "проступать" на фоне меню
                if 400 < own["cursorPos"]["TimerColor"] < 600:
                    if own["cursorPos"]["AlphaColor"] < 1.0:
                        own["cursorPos"]["AlphaColor"] += 0.005
         
                #За все время работы таймера управление прозрачностью курсора идет через словарь свойств
                CursorMenu.color = [1.0, 1.0, 1.0, own["cursorPos"]["AlphaColor"]]
                #И местоположение курсора задется жестко - в центре меню
                CursorMenu.worldPosition = [0.0, 0.0, 0.5]
 
        #И только когда таймер прекратил работу - начинает работать перемещение и клики курсором
        if own["cursorPos"]["TimerColor"] == 600:
            if mouseMotion.positive:
                if own["cursorPos"]["tempX"] != mouseMotion.position[0]:
                    CursorMenu.worldPosition[0] += (mouseMotion.position[0] - own["cursorPos"]["tempX"])/4
                    own["cursorPos"]["tempX"] = mouseMotion.position[0]
                if own["cursorPos"]["tempY"] != mouseMotion.position[1]:
                    CursorMenu.worldPosition[1] -= (mouseMotion.position[1] - own["cursorPos"]["tempY"])/4
                    own["cursorPos"]["tempY"] = mouseMotion.position[1]

                if CursorMenu.worldPosition[0] > 43.0:
                    CursorMenu.worldPosition[0] = 43.0
                if CursorMenu.worldPosition[0] < -45.0:
                    CursorMenu.worldPosition[0] = -45.0
         
                if CursorMenu.worldPosition[1] > 26.0:
                    CursorMenu.worldPosition[1] = 26.0
                if CursorMenu.worldPosition[1] < -24.0:
                    CursorMenu.worldPosition[1] = -24.0
         
            if mouseClick.positive:
                on_click(own)
                if own["cursorPos"]["oldPathFon"] != own["cursorPos"]["newPathFon"]:
                    FonChanging(own)
     
            if own["cursorPos"]["animationButton"] > 0:
                buttonJob(own)
 
        #Эта часть кода отвечает за смену языка - при нажатии кнопок с флажками производится выбор и замена текста     
        if own["cursorPos"]["language"] != bge.logic.globalDict["textGame"]:
            for buttonObj in own["cursorPos"]["listButton"]:
                #Выбираются только кнопки с текстом
                if "IDtext" in buttonObj:
                    if bge.logic.globalDict["textGame"] == "Eng":
                        scene.objects.from_id(int(buttonObj["IDtext"]))["Text"] = buttonObj["textObj"]
                    elif bge.logic.globalDict["textGame"] == "Rus":
                        scene.objects.from_id(int(buttonObj["IDtext"]))["Text"] = buttonObj["textRus"]
            #После замены текста исправляется значение в словаре, чтобы не проверять понапрасну настройки языка по многу раз
            own["cursorPos"]["language"] = bge.logic.globalDict["textGame"]
 
        #Переустановка кнопок и прочего при смене пути к файлу json для данного раздела меню 
        if own["cursorPos"]["newPatchMenu"] != own["cursorPos"]["oldPatchMenu"]:
            GeneratorMenuObj(own)
 
    #СТАРТ ИГРЫ! - переход на игровую сцену 
    if own["cursorPos"]["addSceneGame"] != 0:
        own["cursorPos"]["addSceneGame"] += 1
        if own["cursorPos"]["addSceneGame"] == 20:
            cont.activate(cont.actuators['Scene'])
            own["cursorPos"]["addSceneGame"] = 0
         
#Функция расстановки кнопок и текста, фона раздела меню и так далее - УЗЛОВАЯ ФУНКЦИЯ для FonChanging
def GeneratorMenuObj(own):
    FonObj = None
    Monitor = None
    #Местотоположение курсора задется жестко - в центре меню
    CursorMenu.worldPosition = [0.0, 0.0, 0.5]
 
    #Прежде чем добавлять новые кнопки, удалим старые
    for oldButton in own["cursorPos"]["listButton"]:
        oldButton.endObject()
    own["cursorPos"]["listButton"].clear()

    for textObj in scene.objects:
        if textObj.name == "TextMenu":
            textObj.endObject()
 
    #После очистки экрана от старыхобъектов начинаем создавать новый вид меню, открыв нужный json
    with open(bge.logic.expandPath(own["cursorPos"]["newPatchMenu"]), 'r', encoding = 'utf-8') as directMenu:
        JSONmenu = json.load(directMenu)
 
    if own["cursorPos"]["TimerColor"] == 600:
        for obj in JSONmenu["Buttons"]: 
            newSceneObject = scene.addObject(obj.split('|')[0],own)
            newSceneObject.worldPosition = JSONmenu["Buttons"][obj]["coordObj"]
            newSceneObject.color = JSONmenu["Buttons"][obj]["colorObj"]
            own["cursorPos"]["listButton"].append(newSceneObject)
            if "meshButton" in JSONmenu["Buttons"][obj]:
                newSceneObject.replaceMesh(JSONmenu["Buttons"][obj]["meshButton"],True,False)
            if "scaleObj" in JSONmenu["Buttons"][obj]:
                newSceneObject.worldScale = JSONmenu["Buttons"][obj]["scaleObj"]
            if newSceneObject.name in scaleButtonStandart:
                newSceneObject.worldScale = scaleButtonStandart[newSceneObject.name]
         
            #Иногда нужен текст без кнопки, который еще надо прокручивать 
            if newSceneObject.name == "TextMenu":
                #Печатаем текст из txt файла, находя его по нужному пути
                if "TextPath" in JSONmenu["Buttons"][obj]:
                    newSceneObject["Text"] = ""
                 
            #Задаем кнопке проперти (для прокрутки или других изменений объект помечается тегом "objTag"
            #Кнопка, которая должна управлять изиенениями остальных объектов получает ключ "tagObj", что
            #позволяет ей "опознать" объекты, необходимые для воздействия на них
            if "propObj" in JSONmenu["Buttons"][obj]:
                for key in JSONmenu["Buttons"][obj]["propObj"]:
                    if key not in newSceneObject:
                        newSceneObject[key] = JSONmenu["Buttons"][obj]["propObj"][key]
                             
            if "childObj" in JSONmenu["Buttons"][obj]:
                #Если надо добавляем текст, парентим его к кнопке, выставляем его размер
                newObj = scene.addObject(JSONmenu["Buttons"][obj]["childObj"], newSceneObject)
                newObj.worldPosition[2] = newSceneObject.worldPosition[2] + 0.02
                newObj.worldScale = newSceneObject.worldScale
                newObj.setParent(newSceneObject, False, False)
                if "childObjScale" in JSONmenu["Buttons"][obj]:
                    newObj.worldScale = JSONmenu["Buttons"][obj]["childObjScale"]
     
            #Текст на кнопке
            if "textObj" in JSONmenu["Buttons"][obj]:
                newSceneObject["textObj"] = JSONmenu["Buttons"][obj]["textObj"]
                newSceneObject["textRus"] = JSONmenu["Buttons"][obj]["textRus"]
                #Если надо добавляем текст, парентим его к кнопке, выставляем его размер
                newTextObj = scene.addObject("TextMenu", newSceneObject)
                if "IDtext" not in newSceneObject:
                    newSceneObject["IDtext"] = str(id(newTextObj))
                newTextObj.worldScale = [ newSceneObject.worldScale[1], newSceneObject.worldScale[1], newSceneObject.worldScale[1] ]
                #Выставляем локальные координаты текста
                newTextObj.worldPosition[0] -= 0.8*newSceneObject.worldScale[0]
                newTextObj.worldPosition[1] -= 0.3*newSceneObject.worldScale[1]
                newTextObj.worldPosition[2] += 0.01
                #Печатаем текст на кнопке
                if bge.logic.globalDict["textGame"] == "Rus":
                    newTextObj["Text"] = JSONmenu["Buttons"][obj]["textRus"]
                elif bge.logic.globalDict["textGame"] == "Eng":
                    newTextObj["Text"] = JSONmenu["Buttons"][obj]["textObj"]
     
        #В этом блоке содержатся инструкции по замене мешей и текстур фоновых объектов
        if "meshFonObj" in JSONmenu:
            scene.objects["FonObj"].replaceMesh(JSONmenu["meshFonObj"],True,False)
        #Для монитора (плоскости под фоном) можно задать свой цвет, меш, и координаты
        if "meshMonitor" in JSONmenu:
            scene.objects["Monitor"].replaceMesh(JSONmenu["meshMonitor"],True,False)
        if "coordMonitor" in JSONmenu:
            scene.objects["Monitor"].worldPosition = JSONmenu["coordMonitor"]
        if "scaleMonitor" in JSONmenu:
            scene.objects["Monitor"].worldScale = JSONmenu["scaleMonitor"]
        if "colorMonitor" in JSONmenu:
            scene.objects["Monitor"].color = JSONmenu["colorMonitor"]
        #Замена текстур фоновой плоскости и монитора (необходим для отображения карты террайна и закрытия отверстий в плоскости общего фона)         
        if "pathFonObjTexture" in JSONmenu:
            FonObj = scene.objects["FonObj"]
            own["cursorPos"]["PathFon"] = JSONmenu["pathFonObjTexture"]
            FonChanging(own, FonObj)
        if "pathMonitorTexture" in JSONmenu:
            Monitor = scene.objects["Monitor"]
            own["cursorPos"]["PathFonMonitor"] = JSONmenu["pathMonitorTexture"]
            FonChanging(own, FonObj)
             
        own["cursorPos"]["newPatchMenu"] = own["cursorPos"]["oldPatchMenu"]
       
#Функция смены текстуры фона меню
def FonChanging(own, FonObj):
    pathFon = own["cursorPos"]["PathFon"]
    if FonObj.name == "Monitor": 
        pathFon = own["cursorPos"]["PathFonMonitor"]
    ID = bge.texture.materialID(FonObj, "IM" + FonObj.name + ".jpg")
    object_texture = bge.texture.Texture(FonObj, ID)
    url = bge.logic.expandPath(pathFon)
    new_source = bge.texture.ImageFFmpeg(url)
    bge.logic.texture = object_texture
    bge.logic.texture.source = new_source
    bge.logic.texture.refresh(False)
    FonObj[FonObj.name] = new_source
           
#Функция сработки клика по кнопке - УЗЛОВАЯ ФУНКЦИЯ для buttonMove
def on_click(own):
    #Сработка кнопки идет, когда курсор находится в определенной области, с заданными координатами,
    #проверка которых идет в зависимости от размера кнопки и ее центра, с координатами, уже данными
    #в списке при загрузке и расстановке деталей меню
    for button in own["cursorPos"]["listButton"]:
        if button.worldPosition[0]-button.worldScale[0] < CursorMenu.worldPosition[0] < button.worldPosition[0]+button.worldScale[0]:
            if button.worldPosition[1]-button.worldScale[1] < CursorMenu.worldPosition[1] < button.worldPosition[1]+button.worldScale[1]:
                own["cursorPos"]["indexButton"] = str(id(button))
                own["cursorPos"]["animationButton"] = 1
                buttonMove(own, button)
                     
#Фунция работы кнопки при ее нажатии, действия, направленные на смену разделов или объектов емню, старт или выход из игры   
def buttonJob(own):
    own["cursorPos"]["animationButton"] += 1
    buttonText = None
 
    try:         
        #Находим кнопку под курсором - область координат, ограниченная размером кнопки
        button = scene.objects.from_id(int(own["cursorPos"]["indexButton"]))
     
        #Находим надписи (если есть) и окрашиваем и нажатую кнопку и ее надпись
        if "IDtext" in button:
            buttonText = scene.objects.from_id(int(button["IDtext"]))
        if own["cursorPos"]["animationButton"] == 2:
            button.color = [1.0, 0.0, 1.0, 1.0]
            if buttonText != None:
                buttonText.color = [1.0, 0.0, 1.0, 1.0]
     
        #Окрашиваем незадействованные кнопки в исходный цвет вместе с надписями (если имеются)
        for obj in own["cursorPos"]["listButton"]:
            if obj != button:
                obj.color = [1.0, 1.0, 1.0, 1.0]
                if "IDtext" in obj:
                    scene.objects.from_id(int(obj["IDtext"])).color = [1.0, 1.0, 1.0, 1.0]
     
        #Двигаем кнопку, обнаруживаем и используем ее свойства для смены меню, картинок и сцен 
        if 1 < own["cursorPos"]["animationButton"] < 3:
            button.applyMovement([0.2,-0.2,0.0],True)
            if buttonText != None:
                buttonText.applyMovement([0.2,-0.2,0.0],True)
        if 3 < own["cursorPos"]["animationButton"] < 5:
            button.applyMovement([-0.2, 0.2, 0.0],True)
            if buttonText != None:
                buttonText.applyMovement([-0.2,0.2,0.0],True)
        if own["cursorPos"]["animationButton"] > 4:
            own["cursorPos"]["indexButton"] = ""
            own["cursorPos"]["animationButton"] = 0
            if "GAME_body" in button:
                #Блок для пути к файлу миссии при нажатии кнопки выбора миссии
                if "BGE_globalDict" in button["GAME_body"]:
                    if button["GAME_body"]["BGE_globalDict"] == "pathNameMission":
                        bge.logic.globalDict['currentMission'] = own["cursorPos"]["pathNameMission"]["key_" + str(id(button))]
                #Кнопка выхода из игры
                if button["GAME_body"] == "Stop_Game":
                    bge.logic.endGame()
                #Кнопка перехода на игровую сцену
                if button["GAME_body"] == "Start_Game":
                    own["cursorPos"]["addSceneGame"] = 1
                #Кнопка выбора языка игры
                if "languageGame" in button["GAME_body"]:
                    bge.logic.globalDict["textGame"] = button["GAME_body"]["languageGame"]
                #Это смена пути к файлу раздела меню - меняется само меню, его види кнопки, для кнопки "Назад" или кнопок ивыбора других разделов
                #вроде "Миссии", "Кампании", "Справки" и тому подобных, при котором не происходит выхода из игры
                if "pathJSON" in button["GAME_body"]:
                    own["cursorPos"]["TimerColor"] = 595
                    own["cursorPos"]["newPatchMenu"] = button["GAME_body"]["pathJSON"]
                 
                #Многоступенчатый процесс "опознания" и сравнения тэгов кнопок и текста для их передвижения
                if "tagObj" in button["GAME_body"]:
                    for scrollObj in own["cursorPos"]["listButton"]:
                        if "GAME_body" in scrollObj:
                            #Проверяем совпадение тэгов после их обнаружения
                            if "objTag" in scrollObj["GAME_body"]:
                                #Теперь передвигаем найденный объект
                                if scrollObj["GAME_body"]["objTag"] == button["GAME_body"]["tagObj"]:
                                    if "scrollTagObj" in button["GAME_body"]:
                                        scrollObj.worldPosition[0] += button["GAME_body"]["scrollTagObj"][0]
                                        scrollObj.worldPosition[1] += button["GAME_body"]["scrollTagObj"][1]
                                     
                                        if "nullCoordX" in scrollObj["GAME_body"]:
                                            if scrollObj.worldPosition[0] < scrollObj["GAME_body"]["nullCoordX"]:
                                                scrollObj.worldPosition[0] = scrollObj["GAME_body"]["nullCoordX"]
                                            if scrollObj.worldPosition[0] > own["cursorPos"]["limitXscroll"]:
                                                scrollObj.worldPosition[0] -= scrollObj["Game_body"]["limitXscroll"]
                                                if "listDriverObj" in scrollObj["GAME_body"]:
                                                    for scrollChild in scrollObj["GAME_body"]["listDriverObj"]:
                                                        scrollChild.worldPosition[0] += scrollObj["GAME_body"]["scaleAddObj"][0]*button["GAME_body"]["valueButton"] #     own["cursorPos"]["limitXscroll"]
                                         
                                        if "nullCoordY" in scrollObj["GAME_body"]:
                                            #print(scrollObj.name)
                                            if scrollObj.worldPosition[1] < scrollObj["GAME_body"]["nullCoordY"]:
                                                scrollObj.worldPosition[1] = scrollObj["GAME_body"]["nullCoordY"]
                                            if scrollObj.worldPosition[1] > scrollObj["Game_body"]["limitYscroll"]:
                                                scrollObj.worldPosition[1] -= own["cursorPos"]["limitYscroll"]
                                                if "listDriverObj" in scrollObj["GAME_body"]:
                                                    for scrollChild in scrollObj["GAME_body"]["listDriverObj"]:
                                                        scrollChild.worldPosition[1] += scrollObj["GAME_body"]["scaleAddObj"][1]*button["GAME_body"]["valueButton"]  #own["cursorPos"]["limitYscroll"]
                             
                                #Изменение текста на объекте TextMenu, например при смене текста справки для видов юнитов
                                if "changTextTagObj" in button["GAME_body"]:
                                    if "pathButtonTXT" not in button["GAME_body"]["changTextTagObj"]:
                                        with open(bge.logic.expandPath(button["GAME_body"]["changTextTagObj"]+bge.logic.globalDict["textGame"]+".txt"), 'r', encoding = 'utf-8') as MenuHelpTXT:
                                            scrollObj["Text"] = MenuHelpTXT.read()
                                        #print(scrollObj.name)
                                        #with open(bge.logic.expandPath(button["GAME_body"]["changTextTagObj"]+bge.logic.globalDict["textGame"]+".txt"), 'r', encoding = 'utf-8').readlines() as changText:
                                            #own["cursorPos"]["limitYscroll"] = scrollObj.worldScale[1]*len(changText)
                                         #   scrollObj["Game_body"]["limitYscroll"] = scrollObj.worldScale[1]*len(changText)
                                    else:
                                        with open(bge.logic.expandPath(own["cursorPos"]["pathButtonTXT"]["key_"+str(id(button))]+bge.logic.globalDict["textGame"]+".txt"), 'r', encoding = 'utf-8') as MenuHelpTXT:
                                            scrollObj["Text"] = MenuHelpTXT.read()
                                     
                                if "changButtonTagObj" in button["GAME_body"]:
                                    if "listDriverObj" in scrollObj["GAME_body"]:
                                        own["cursorPos"]["pathButtonTXT"] = {}
                                        #Убираем кнопки из списка драйвера объекта
                                        if len(scrollObj["GAME_body"]["listDriverObj"]) != 0:
                                            for objOLD in scrollObj["GAME_body"]["listDriverObj"]:
                                                if objOLD in own["cursorPos"]["listButton"]:
                                                    own["cursorPos"]["listButton"].remove(objOLD)
                                                #scrollObj["GAME_body"]["listDriverObj"].remove(objOLD)
                                                objOLD.endObject()
                                            own["cursorPos"]["valueButtonCoord"] = [0.0,0.0,0.0]
                                            scrollObj["GAME_body"]["listDriverObj"] = []
                                     
                                        with open(bge.logic.expandPath('//NodePath.json'), 'r', encoding = 'utf-8') as NODEPATH:
                                            jsonButtonPath = json.load(NODEPATH)
                                            for pathButton in jsonButtonPath:
                                                if button["GAME_body"]["changButtonTagObj"] in pathButton:
                                                    if ".json" in pathButton:
                                                        newObjGen = scene.addObject(scrollObj["GAME_body"]["addObjName"], scrollObj)
                                                        scrollObj["GAME_body"]["listDriverObj"].append(newObjGen)
                                                        own["cursorPos"]["listButton"].append(newObjGen)
                                                        newObjGen.replaceMesh(scrollObj["GAME_body"]["meshAddObj"], True, False)
                                                        newObjGen.worldScale = scrollObj["GAME_body"]["scaleAddObj"]
                                                        own["cursorPos"]["valueButtonCoord"][0] += scrollObj["GAME_body"]["valueCoord"][0]
                                                        own["cursorPos"]["valueButtonCoord"][1] += scrollObj["GAME_body"]["valueCoord"][1]
                                                        own["cursorPos"]["valueButtonCoord"][2] += scrollObj["GAME_body"]["valueCoord"][2]
                                                        newObjGen.worldPosition[0] += own["cursorPos"]["valueButtonCoord"][0]
                                                        newObjGen.worldPosition[1] += own["cursorPos"]["valueButtonCoord"][1]
                                                        newObjGen.worldPosition[2] += own["cursorPos"]["valueButtonCoord"][2]
                                                     
                                                        if "textChild" in scrollObj["GAME_body"]:
                                                            with open(bge.logic.expandPath(pathButton), 'r', encoding = 'utf-8') as textButton:
                                                                jsonTextButton = json.load(textButton)
                                                                newTextGen = scene.addObject("TextMenu", newObjGen)
                                                                scrollObj["GAME_body"]["listDriverObj"].append(newTextGen)
                                                                own["cursorPos"]["listButton"].append(newTextGen)
                                                                newTextGen.worldScale = scrollObj["GAME_body"]["textChild"]
                                                                newTextGen.color = scrollObj["GAME_body"]["textChildColor"]
                                                                if bge.logic.globalDict["textGame"] == "Rus":
                                                                    newTextGen["Text"] = jsonTextButton["textRus"]
                                                                elif bge.logic.globalDict["textGame"] == "Eng":
                                                                    newTextGen["Text"] = jsonTextButton["textEng"]
                                                                #Выставляем локальные координаты текста
                                                                newTextGen.worldPosition[0] -= 0.8*newObjGen.worldScale[0]
                                                                newTextGen.worldPosition[1] -= 0.15*newObjGen.worldScale[1]
                                                             
                                                        if "addObjGAME_body" in scrollObj["GAME_body"]:
                                                            newObjGen["GAME_body"] = scrollObj["GAME_body"]["addObjGAME_body"]
                                                            if "BGE_globalDict" in newObjGen["GAME_body"]:
                                                                if newObjGen["GAME_body"]["BGE_globalDict"] == "pathNameMission":
                                                                    if "key_" + str(id(newObjGen)) not in own["cursorPos"]["pathNameMission"]:
                                                                        own["cursorPos"]["pathNameMission"]["key_" + str(id(newObjGen))] = pathButton
                                                                        #print(own["cursorPos"]["pathNameMission"])   
                                                            if "key_" + str(id(newObjGen)) not in own["cursorPos"]["pathButtonTXT"]:
                                                                own["cursorPos"]["pathButtonTXT"]["key_" + str(id(newObjGen))] = pathButton.split(".json")[0] + "_"
                                                                                                           
    except:
        print(error)
        own["cursorPos"]["indexButton"] = ""
 
#Функция звукового сопровождения и выдачи на кнопку свойств проперти
def buttonMove(own, button):
    cont = bge.logic.getCurrentController()
    audioTemp = cont.actuators['SoundClick']
 
    if "GAME_body" in button:
        if "scrollTagObj" not in button["GAME_body"]:
            cont.activate(audioTemp)
 
    if "GLOBAL_DICT_name" in button:
        if "GLOBAL_DICT_body" in button:
            if button["GLOBAL_DICT_name"] not in bge.logic.globalDict:
                bge.logic.globalDict[button["GLOBAL_DICT_name"]] = button["GLOBAL_DICT_body"]
            else:
                bge.logic.globalDict[button["GLOBAL_DICT_name"]] = button["GLOBAL_DICT_body"]
             
#Поиск путей к файлам, выстраивание списков, ОЧЕНЬ ВАЖНОЕ СТАРТОВОЕ ДЕЙСТВИЕ
startPath()

Функция startPath срабатывает всегда только один раз, отыскивая пути и файлы и добавляя их в список файла json NodePath. Это - ключ ко всему. Там расположены пути к файлам blend и файлы json  с описаниями объектов. Из-за этого файла я и решил в итоге фактически все начать с нуля. Пусть объекты сами ищут пути к нужным данным, вскрывают нужные файлы и действуют по заданным инструкциям. Раньше надо было это делать, ну да ладно, опыт сын ошибок трудных...
Фото были взяты из Сети, временно, потом будут заменены на скрины из самой игры.

Меню справки для юнитов разных "сред". Вверху - меню выбора миссии с коротким описанием оной.

Так пока и не доделанное меню редактора.

Стартовое меню.

     
             
 


                         

Бюрократия. Ревизионизм. Реанимация. Тестирование. Су-25. И снова про blf - избавление от кракозябр.

Следующим после МиГ-27К к реанимации был назначен Су-25. Работа выдалась вполне рутинной. Сначала. А вот потом вдруг всплыла нерешенная еще в пераой версии проблема - кабина Су-25, которую я перенес во вторую версию, была меньше требуемых размеров. Произошло это из-за ошибки в моделировании Су-25 в первой версии. Тогда я вывернулся с оверлейной сценой и благополусно забыл об этом. во второй версии из-за ряда новых нюансов подобная халява не прокатила и пришлось кабину "увеличивать". А вместе с ней и остальные детали - индикаторы, стрелочки и тд. Также пришлось подгонять названия деталей под единый стандарт и править текст скрипта работы приборов. Попутно выяснил, что можно UV-скроллинг задавать из единого центра, называя имена объектов в скрипте - все равно мешей у них в списке всего один. по-видимому, придется все кабины зачистить от лишней логики работы курвиметров и вообще потихоньку оптимизировать скрипты, перечислив газвания стрелочек в "шапках" модулей. Ну, ладно, не в первый раз оптимизирую.
Пришлось повозиться с json для Су-25. Постоянно выплывала ошибка в строке с данными сенсора. В конце концов мое терпение лопнуло и я ее заменил на строчку из другого json, подкорректировав цифры. Ошибка пропала. Что это было я так и не понял.
Установил в кабине прицел АСП-17, про который я писал уже в своем блоге здесь, но пока толком не тестировал.
Большую работу пришлось проделать с меню. Серией различных ухищрений мне удалось достичь того, что теперь текст может более-менее точно располагаться на кнопке, а не только рядом с ней, он может быть русским или английским, иметь определенный цвет и прозрасность. К сожаленпию, смена текстур в 2.78 была таки сломана, да и видеотекстура теперь работает странно... Так что смена заставок в меню была сделана через замену мешей, зато раотает железно.
Наконец, с подсказки dron-а, были ликвидированы жуткие кракозябры вместо русского текста. Понятно, что во всем была виновата кодировка. преодолевается это так:

 with open(bge.logic.expandPath('//Menu/StartMenu.json'), 'r', encoding = 'utf-8') as directMenu:
        JSONmenu = json.load(directMenu)

В данном случае encoding = 'utf-8' - это убийца кракозябр. Русский текст после этого нормально воспринимается и читается в БГЕ и можно его пропечатать на экране хоть в текстовом объекте, хоть в blf. Кстати о последнем. Я уже писал о выведении текста на экран. У меня работают текстовые метки целей (наконец-то получилось отсечь цели позади активной камеры),  но надо было обязательно сделать меню справку о клавишах и командах. Приводить весь текст json, пожалуй, не буду, он длинный и однообразный. Приведу строчку с разъяснением структуры, хотя, там скорее всего и так будет более-менее поянтно.

"str1":{"az":35,"buki":45,"vediR":1.0,"vediG":1.0,"vediB":1.0,"vediA":1.0,"strX":0.01,"strY":0.975,
        "textRus":"Команды","textEng":"Option"},
"str2":{"az":35,"buki":45,"vediR":1.0,"vediG":1.0,"vediB":1.0,"vediA":1.0,"strX":0.01,"strY":0.95,
        "textRus":"+ - увеличение тяги двигателя","textEng":"+ - Engine power plus"}

Хотя нет, не все. Тут еще дело упирается в мой специфический юмор. Недолго думя, я обозвал переменные сами видите как. az и buki - это размер текста. vedi с заглавными буквами - это цвет и прозрасность текста - RGBA, strX-Y- координаты начала строчки на экране. Далее понятно - русский и английский текст. Дело в том, что я постепенно наращивал число ключей в словаре json, не зная толком, что понадобится в работе - в итоге вот так и получилось. Хотя можно и упростить.
Как бы то ни было, меню стало более вменяемым и происходит его сборка-пересборка при смене разделов. у меня не было ни малейшего желания громоздить кучу сцен ради меню, надеюсь, удастся итоговую сцену тоже не делать, а возвращаться в сцену с меню.
И да, наконец удалось ввести в сцену террайна наземную цель - бункер, взаимодействие которого при попадании оружия еще надо как-то отработать - обрушение, разлет обломков там...
Пока меню имеет пять миссий - для МиГ-23МФ и МиГ-29  это перехват Ф-16 и Ф-15 соответственно. Для Су-25, МиГ-23БН и МиГ-27К  я противников из воздуха убрал, но оставил в качестве цели бункер. Надо попробовать ввести МЗА и СЗРК. В первой версии МЗА "Эрликон" был, надо перетаскивать. Плюс "Стрела-1" и БРДМ-2, но их текстурить надо. Когда-то я сделал модель БМП-1. Ее надо избавить от высокополигональных катков и гусениц, посмотреть, что можно упростить и туда же, тем более, она была затекстурена...
В общем, продолжим...
Ниже скрины - нельзя же совсем ез картинок - Су-25 и его кабина. Подвешены по две пары блоков С-8 и бомб ФАБ-250, плюс пара ракет Р-60М.

Меню, руины и прочая лабуда. Дао дятла.

После недолгого скорбного замешательства, вызванного серией неудачных попыток создать хоть что-нибудь, изображающее меню с возможностью выбора миссии, эту задачу все же удалось решить. Частично. Все упиралось в генерацию кнопок, а также придании им нужных свойств. Очень не хотелось вешать на кнопки логические кирпичи, ограничив все бриками на камере сцены меню. чтобы потом не искать судорожног нужную логику на нужном объекте, да еще и на нужном слое. как водится, с первого и даже с третьего раза не вышло. По моей просьбе dron сделал пример с применением положения курсора мыши. именно в нем и был затык - как-то так вышло, что с курсором мыши я никогда не работал раньше и кнопки меню первой версии обладали своей логикой.
Однако выяснилось, что вменяемое управление кнопками с этим крсором создать сложно - необходимо пересчитывать экранные координаты и мировые координаты кнопок просто так не персчитаешь. В довершение ко всему, игра может быть и не во весь экран, и тд и тп.
Опять извечный русский вопрос - что делать? Ну, раз стандартный курсор не  помогает, можно и свой запилить. Ниже привожу код, в котором есть функция cursorPos -  это и есть самодельный курсор. суть в том, что некий объект на экране постоянно сравнивает положение курсора мыши с положением его же в предыдущем тике (опять словари). Тут идет просто копирование направление движения курсора мыши в нужном направлении. Скорость передвижения самодельного курсора пришлось понизить, а то он летал с бешеной скоростью. Плюс ввести ограничения, чтобы курсор из плейна не вылетал за пределы меню.
import json
#import bgl
#import blf

scene = bge.logic.getCurrentScene()
PlaneCursor = scene.objects["PlaneCursor"]



#Далее идет блок клавиатурных команд
keyboard = bge.logic.keyboard
JUST_ACTIVATED = bge.logic.KX_INPUT_JUST_ACTIVATED
JUST_RELEASED = bge.logic.KX_INPUT_JUST_RELEASED
INPUT_ACTIVE = bge.logic.KX_INPUT_ACTIVE

cont = bge.logic.getCurrentController()
own = cont.owner

if "cursorPos" not in own:
    own["cursorPos"] = {"tempX":0.0,"tempY":0.0,
                        "listButton":[],"animationButton":0,
                        "indexButton":""}



def textureFonLoad(own, nameTexture):
    #bge.logic.expandPath("//Menu/textureMenu/" + nameTexture)
    obj = scene.objects["FonMenu"]
   
    ID = bge.texture.materialID(obj, 'IMStartFon.png')
    object_texture = bge.texture.Texture(obj, ID)
    url = bge.logic.expandPath("//Menu/textureMenu/" + nameTexture)
    new_source = bge.texture.ImageFFmpeg(url)
    bge.logic.texture = object_texture
    bge.logic.texture.source = new_source
    bge.logic.texture.refresh(False)
    obj["FonMenuTexture"] = new_source
   
    
   
def cursorPos():
    cont = bge.logic.getCurrentController()
    own = cont.owner
   
    if own["cursorPos"]["animationButton"] > 0:
        buttonMotion(own)      
   
    mouseNot = cont.sensors["MouseNot"]
   
    if mouseNot.positive:
        if own["cursorPos"]["tempX"] != mouseNot.position[0]:
            PlaneCursor.worldPosition[0] += (mouseNot.position[0] - own["cursorPos"]["tempX"])/4
            own["cursorPos"]["tempX"] = mouseNot.position[0]
        if own["cursorPos"]["tempY"] != mouseNot.position[1]:
            PlaneCursor.worldPosition[1] -= (mouseNot.position[1] - own["cursorPos"]["tempY"])/4
            own["cursorPos"]["tempY"] = mouseNot.position[1]

        if PlaneCursor.worldPosition[0] > 45.0:
            PlaneCursor.worldPosition[0] = 45.0
        if PlaneCursor.worldPosition[0] < -45.0:
            PlaneCursor.worldPosition[0] = -45.0
           
        if PlaneCursor.worldPosition[1] > 25.0:
            PlaneCursor.worldPosition[1] = 25.0
        if PlaneCursor.worldPosition[1] < -25.0:
            PlaneCursor.worldPosition[1] = -25.0
       
       

def on_click(cont):
   
    if cont.sensors["Mouse"].positive:
        #print(own["cursorPos"]["listButton"])
        for button in own["cursorPos"]["listButton"]:
            if button.worldPosition[0]-0.9 < PlaneCursor.worldPosition[0] < button.worldPosition[0]+0.9:
                if button.worldPosition[1]-0.9 < PlaneCursor.worldPosition[1] < button.worldPosition[1]+0.9:
                    own["cursorPos"]["indexButton"] = str(id(button))
                    own["cursorPos"]["animationButton"] = 1
                    buttonMove(own, button)
       
       
def buttonMotion(own):
   
    own["cursorPos"]["animationButton"] += 1
    try:
        button = scene.objects.from_id(int(own["cursorPos"]["indexButton"]))
        if 1 < own["cursorPos"]["animationButton"] < 3:
            button.applyMovement([0.3,-0.3,0.0],True)
        if 3 < own["cursorPos"]["animationButton"] < 5:
            button.applyMovement([-0.3,0.3,0.0],True)
        if own["cursorPos"]["animationButton"] > 4:
            own["cursorPos"]["indexButton"] = ""
            own["cursorPos"]["animationButton"] = 0
            if "GAME_body" in button:
                if button["GAME_body"] == "Stop_Game":
                    bge.logic.endGame()
                elif button["GAME_body"] == "Start_Game":
                    own["startGame"] = 1
    except:
        own["cursorPos"]["indexButton"] = ""

def buttonMove(own, button):
    if "GLOBAL_DICT_name" in button:
        if "GLOBAL_DICT_body" in button:
            if button["GLOBAL_DICT_name"] not in bge.logic.globalDict:
                bge.logic.globalDict[button["GLOBAL_DICT_name"]] = button["GLOBAL_DICT_body"]
            else:
                bge.logic.globalDict[button["GLOBAL_DICT_name"]] = button["GLOBAL_DICT_body"]
               
   

def control():
    cont = bge.logic.getCurrentController()
    own = cont.owner
   
    listButton = []
    with open(bge.logic.expandPath('//Menu/' + 'Test_Missions' + '.json'), 'r') as directMenu:
        JSONmenu = json.load(directMenu)
   
    nameTexture = "FonSingleMission.png"
    textureFonLoad(own, nameTexture)
   
    for obj in JSONmenu["Buttons"]:   
        newSceneObject = scene.addObject(obj.split('|')[0],own)
        newSceneObject.worldPosition = JSONmenu["Buttons"][obj]["coordObj"]
        newSceneObject.color = JSONmenu["Buttons"][obj]["colorObj"]
        newSceneObject.worldScale = JSONmenu["Buttons"][obj]["scaleObj"]
        own["cursorPos"]["listButton"].append(newSceneObject)
        #Задаем кнопке проперти
        for key in JSONmenu["Buttons"][obj]["propObj"]:
            if key not in newSceneObject:
                newSceneObject[key] = JSONmenu["Buttons"][obj]["propObj"][key]
        if "TextButtons" in newSceneObject.childrenRecursive:
            with open(bge.logic.expandPath('//Menu/TranslationMenu.txt'), 'r') as TranslationMenu:
                for stringer in TranslationMenu:
                    if stringer[0] == "a":
                        if stringer.split('|')[1] == JSONmenu["Buttons"][obj]["textObj"]:
                            newSceneObject.childrenRecursive["TextButtons"]["Text"] = stringer.split('|')[1]
   

В сущности, сначала идет чтение json для расстановки кнопок и придания им нужных свойств - стандартная операция, затем опять стандартная операция - расстановка кнопок и присваивание им свойств - одноразовая вещь (пока) - ничего сложногог. Затем начинает работать курсор. Просто сравнивается положение курсора в момент щелчка кнопкой мыши с положением  кнопок и кнопки дергаются при попадании в некоторую область (buttonMotion), функция buttonMove как раз что-то пишет в глобальный словарь, например, название миссии.
В конце концов, меню заработало, обеспечив выбор аж двух миссий со стартом игры или выходом из нее.
После меню последовало создание наземных статичных объектов. Таковыми были выбраны руины. Из гугловских моделей в качестве времнной (надеюсь) затычки были закачаны с десяток моделей и терепеливо обработаны до удобоваримого состояния в Блендер. Плюс была создана модель аэродрома из одного объекта.
Теперь консоль матерится на лишние UV-развертки. Пока приходится терпеть. Руины и авиабазы были вписаны в json миссий и проврены. пока без маркировки и присущих им совйств.
Есть предположение, что для относительно простых объектов можно реализовать частичное разрушение меша. Условно, конечно, удалять вершины нельзя, но их можно двигать. Суть в том, что при попадании снаряда в нужной области меша все вершины в этой области принимают нулевое значение координаты Зет (по высоте), как бы сплющиваются. а вторым циклом все вершины в данном "квадрате" , находящиеся, скажем, ниже 50, получают прибавку к своим координатам по оси Зет - на месте "целого" ангара (чсти меша) появляются развалины. Правда, для этого, объект должен быть относительно простым. Ну, для простейших кубиков - ангаров, сраев и домиков сойдет...
Далее последовало создание катапультируемого пуска для ракет. Это надо было сделать давно, но руки дошли только сейчас. Суть в том, что сначала ракета отбрасывается от самолета вниз, и только потом включается двигатель. С первой попытки не удалось, но руководствуясь дао дятла, я повторил попытку, специально для такого случая учредив новый тип физического движения в игре - отсроченный старт... В конце концов заработалог...
Вообще все вышеперчисленное не слишком повлияло на уже существующую картинку, поэтому скринов не будет. Зато впереди полно работы по доводке json F-15 под этот самый катапультируемый пуск. А куда деваться.
-Вот ты говоришь: "Мафия! Мафия!". Конечно хотелось бы, чтобы у нас была мафия, но для этого надо много работать, - говорил герой Николая Караченцова в фильме "Дежа Вю". Последую же этому призыву, не мафии ради, но для красивой картинки на экране. Которая непременно появится. Когда-нибудь...

 

Возвращаясь к напечатанному. Работа с blf - текстовые маркеры.

В конце прошлого года с помощью dron-fя ввел текстовый маркер цели на эуране. Об этом я подробно писал в посте о работе с blf и приводил срипт с кодом. Прошло время и я вновь был вынужден заняться этой темой. Как известно, во многих играх существуют текстовые подсказки, которые, как правило, сопровождают юниты или предметы, показывают боекомплект, направление движения и так далее.
В том варианте скрипта текстовый маркер был один и касался он только одной - захваченной цели. Однако хотелось получить более полную информацию об обстановке вокруг и иметь возможность включения-выключения текстовых маркеров. Практически с первой попытки удалось добиться маркировки всех целей в поле зрения камеры, плюс маркировка выбранной цели. Однако скрипт вышел усложненным и корявым. dron указал на некоторые мои промахи (в частности совершенно ненужный повторный вызов функций), после чего я вновь переработал скрипт. Пришлось вводить функцию "затирания" текста, иначе маркеры не выключались. Дополнительно пришлось переводить индекс выбранной цели в глобальный словарь,дописать строчки кода для выбора режима отображения информации - но это так - по мелочам. Теперь скрипт имеет измененный вид, но изменения еще произойдут, поскольку Андрей в своих подсказках применил мною ранее не употреблявшиеся способы форматирования текста и их требуется осмыслить  и принять на вооружение.Итак, код (надо еще разобраться с подсветкой кода в Блоггере - первая попытка окончилась провалом - но программист в html из меня не очень пока что):

import bge
import bgl
import blf

#МЕТКИ ЦЕЛИ НА КОЛЛИМАТОРЕ - ОБЕСПЕЧИВАЕТСЯ ЕЕ ПЛАВНОЕ ПЕРЕМЕЩЕНИЕ ВСЛЕД ЗА ЦЕЛЬЮ  
#Чтение экранных координат    
def readCoord():
    cont = bge.logic.getCurrentController()
    scene = bge.logic.getCurrentScene()
    own = cont.owner
    camera = scene.active_camera
   
    targetLabel = scene.objects['targetMarka']
   
    camera = scene.active_camera
   
    #Метка цели работает только при включенном радаре и выставленной дальности
    try:
        #
        marka = own.getScreenPosition(targetLabel)
       
        if abs(marka[0] - bge.logic.globalDict['targetCoord'][0]) > 0.001:
            targetLabel.worldPosition[0] -= (marka[0] - bge.logic.globalDict['targetCoord'][0])/5
        if abs(marka[1] - bge.logic.globalDict['targetCoord'][1]) > 0.001:
            targetLabel.worldPosition[2] += (marka[1] - bge.logic.globalDict['targetCoord'][1])/5
       
        plusX = targetLabel['limXplus'] #collimatorRight.worldPosition[0]
        minusX = targetLabel['limXminus'] #collimatorLeft.worldPosition[0]
        plusY = targetLabel['limYplus'] #collimatorRight.worldPosition[2]
        minusY = targetLabel['limYminus'] #collimatorLeft.worldPosition[2]
         
        if targetLabel.worldPosition[0] < minusX:
            targetLabel.worldPosition[0] = minusX
        elif targetLabel.worldPosition[0] > plusX:
            targetLabel.worldPosition[0] = plusX
        if targetLabel.worldPosition[2] < minusY:
            targetLabel.worldPosition[2] = minusY
        elif targetLabel.worldPosition[2] > plusY:
            targetLabel.worldPosition[2] = plusY
       
       
           
    except:
        centerX = (targetLabel['limXminus'] + targetLabel['limXplus'])/2
        centerY = (-targetLabel['limYminus'] + targetLabel['limYplus'])/2
        targetLabel.worldPosition[0] = centerX
        targetLabel.worldPosition[2] = centerY

def writeCoord():
    cont = bge.logic.getCurrentController()
    scene = bge.logic.getCurrentScene()
    own = cont.owner
    bge.logic.font_id = 0 #blf.load(font_path)
   
    if 'localDict' not in own:
        own['localDict'] = {'typeWriteCoord':own['typeWriteCoord']}
    else:
        if own['localDict']['typeWriteCoord'] != own['typeWriteCoord']:
            #Однократный прогон функции стирания текста при выкоючении маркеров
            if own['typeWriteCoord'] == 0:
                scene.post_draw = [resetWrite]
            own['localDict']['typeWriteCoord'] = own['typeWriteCoord']
       
        #Маркеры текстовой информации включены
        if own['typeWriteCoord'] == 1:
            scene.post_draw = [write]
        #Если макеры выключены, работает  упрощенная функция слежения только за одной целью  
        else:
            targetWrite()
   
   

def write():
    scene = bge.logic.getCurrentScene()
    camera = scene.active_camera
   
    width = bge.render.getWindowWidth()
    height = bge.render.getWindowHeight()
 
    textInfo = ''
    distance = 0
   
    targetInScene = 0
   
    bgl.glDisable(bgl.GL_DEPTH_TEST)
    bgl.glMatrixMode(bgl.GL_PROJECTION)
    bgl.glLoadIdentity()
    bgl.gluOrtho2D(0, width, 0, height)
    bgl.glMatrixMode(bgl.GL_MODELVIEW)
    bgl.glLoadIdentity()
    font_id = bge.logic.font_id
   
   
    if len(bge.logic.globalDict['listAllObject']) > 0:
       for target in bge.logic.globalDict['listAllObject']:
           #Отрисовке информации подлежат только объекты в поле зрения камеры
           if -0.6 < camera.getVectTo(target)[2][0] < 0.6 or str(id(target)) == bge.logic.globalDict['idTarget']:
               #Несколько коряво с повтором условия
               if -0.32 < camera.getVectTo(target)[2][1] < 0.32 or str(id(target)) == bge.logic.globalDict['idTarget']:
                   if camera.getDistanceTo(target) > 30:
                     
                       ScreenPositionTarget = camera.getScreenPosition(target)
                     
                       winXcoord = bge.render.getWindowWidth(target) * ScreenPositionTarget[0]
                       winYcoord = bge.render.getWindowHeight(target) *(1-ScreenPositionTarget[1])
                 
                       distance = int(camera.getDistanceTo(target)/1000)
                       #Формируем текстовый блок
                       textInfo = target['unitName'] + target['unitNation'] + str(distance)
                     
                       blf.position(font_id, winXcoord, winYcoord, 0)
                       blf.size(font_id, 25, 36)
                       if target['target'] == 0:
                           bgl.glColor3f(1.0,0.0,0.0)
                       if target['target'] == 1:
                           bgl.glColor3f(0.0,0.0,1.0)
                       #bgl.glColor4f
                       bgl.glDisable(bgl.GL_LIGHTING)
                       blf.draw(font_id, textInfo)
                       blf.draw(font_id, textInfo)
                     
                       #Для захваченной цели
                       if str(id(target)) == bge.logic.globalDict['idTarget']:
                           targetInScene = 1
                           bge.logic.globalDict['targetCoord'] = ScreenPositionTarget
                           targetDistance = camera.getDistanceTo(target)
                           targetSpeed = target.localLinearVelocity[1]
                           targetHeight = target.worldPosition[2]
                           bge.logic.globalDict['targetData'] = [targetDistance, targetSpeed, targetHeight]
                 
    #Последнее уточнение -  если после прохождения цикла цели в сцене не имеется
    if targetInScene == 0:
        bge.logic.globalDict['targetCoord'] = [0, 0]
        bge.logic.globalDict['targetData'] = [0, 0, 0]
   
    bgl.glEnable(bgl.GL_DEPTH_TEST)
               

#Упрощенная функция чтения экранных координат целм
def targetWrite():
    cont = bge.logic.getCurrentController()
    scene = bge.logic.getCurrentScene()
    own = cont.owner
   
    try:
        target = scene.objects.from_id(int(own['idTarget']))
        camera = scene.active_camera
        bge.logic.globalDict['targetCoord'] = camera.getScreenPosition(target)
        targetDistance = own.getDistanceTo(target)
        targetSpeed = target.localLinearVelocity[1]
        targetHeight = target.worldPosition[2]
        bge.logic.globalDict['targetData'] = [targetDistance, targetSpeed, targetHeight]
    except:
        bge.logic.globalDict['targetCoord'] = [0, 0]
        bge.logic.globalDict['targetData'] = [0, 0, 0]
       
#Функция сброса экранных маркеров  
def resetWrite():
    scene = bge.logic.getCurrentScene()
    camera = scene.active_camera
    width = bge.render.getWindowWidth()
    height = bge.render.getWindowHeight()
    #bgl.glDisable(bgl.GL_DEPTH_TEST)
    bgl.glMatrixMode(bgl.GL_PROJECTION)
    bgl.glLoadIdentity()
    bgl.gluOrtho2D(0, width, 0, height)
    bgl.glMatrixMode(bgl.GL_MODELVIEW)
    bgl.glLoadIdentity()
    font_id = bge.logic.font_id
    blf.position(font_id, 0, 0, 0)
    blf.size(font_id, 25, 36)
    bgl.glDisable(bgl.GL_LIGHTING)
    blf.draw(font_id, '')
    blf.draw(font_id, '')
    #bgl.glEnable(bgl.GL_DEPTH_TEST)
               

Ну и, как это выглядит на экране. Пара Ф-16 с национальной принадлежностью и дистанцией в км. Кстати, при тестировании, когда мой МиГ-23МФ был сбит и камера "отсоединилась", то я увидел и красную строчку с указанием моего юнита и дистанцией с нацпринадлежностью (когда сбитый самолет пошел вперед и вниз). Клавиша М(лат) срабатывает - можно включать и отключать текст.