d05 Начало глубокой структуризации

pkg/alias/alias.go

@@ -21,3 +21,12 @@ type Мин uint
 
 // Сек -- количество секунд
 type Сек uint
+
+// СценаИмя -- имя сцены
+type СценаИмя string
+
+// СценаРежим -- режим сцены (не существует, апгрейд, ожидание, работа)
+type СценаРежим string
+
+// СценаРабота -- работа сцены (серебро-1. серебро-3, ремка-4 и т.п.)
+type СценаРабота string

pkg/components/kernel/slog/slog.go

@@ -119,7 +119,7 @@ func (sf *Slog) printf(pref, str string, lstVal ...interface{}) {
 	strTime := time.Now().Local().Format("2006-01-02 15:04:05.000\t")
 	sf.buf.WriteString(strTime + "\t")
 	sf.buf.WriteString(pref + "\t")
-	sf.buf.WriteString(cons.SelfName + "\n\t")
+	sf.buf.WriteString(cons.СамИмя + "\n\t")
 	sf.buf.WriteString(fmt.Sprintf(str, lstVal...))
 	sf.lf.Write(sf.buf.String())
 	sf.lt.Write(style + sf.buf.String() + "\033[00m")

pkg/components/kernel/slog/slog_file/slog_file.go

@@ -39,7 +39,7 @@ func NewSlogFile(kern types.IKernel, build string) (*SlogFile, error) {
 	}
 	sf := &SlogFile{
 		kern:     kern,
-		fileName: cons.SelfName + "_" + build + time.Now().UTC().Format("_2006-01-02 15:04:05.000") + ".log",
+		fileName: cons.СамИмя + "_" + build + time.Now().UTC().Format("_2006-01-02 15:04:05.000") + ".log",
 		isWork:   safe_bool.НовБезопБул(),
 		chMsg:    make(chan []byte, 10),
 	}

pkg/components/section_net/netclient/netclient.go → pkg/components/scene_net/netclient/netclient.go

@@ -9,7 +9,7 @@ import (
 	"sync"
 	"time"
 
-	"wartank/pkg/components/section_net/netstat"
+	"wartank/pkg/components/scene_net/netstat"
 	"wartank/pkg/types"
 )
 

pkg/components/section_net/section_net.go → pkg/components/scene_net/section_net.go

@@ -1,5 +1,5 @@
-// package section_net -- сетевая секция
-package section_net
+// package scene_net -- сетевая сцена
+package scene_net
 
 import (
 	"fmt"
@@ -12,12 +12,8 @@ import (
 	"wartank/pkg/types"
 )
 
-/*
-	Базовый тип для сетевых секций
-*/
-
-// СекцияСеть -- базовый тип для сетевых секций
-type СекцияСеть struct {
+// СекцияСеть -- базовый тип для сетевых сцен
+type СценаСеть struct {
 	клиент types.ИСетьКлиент
 	секция types.ИСценаСтр
 	стрУрл string
@@ -25,7 +21,7 @@ type СекцияСеть struct {
 }
 
 // НовСекцияСеть -- возвращает новый *СекцияСеть
-func НовСекцияСеть(сцена types.ИСценаСтр, стрУрл string) (*СекцияСеть, error) {
+func НовСекцияСеть(сцена types.ИСценаСтр, стрУрл string) (*СценаСеть, error) {
 	log.Printf("НовСекцияСеть(): url=%q\n", стрУрл)
 	{ // Предусловия
 		if сцена == nil {
@@ -35,7 +31,7 @@ func НовСекцияСеть(сцена types.ИСценаСтр, стрУр
 			return nil, fmt.Errorf("НовСекцияСеть(): strUrl is empty")
 		}
 	}
-	сам := &СекцияСеть{
+	сам := &СценаСеть{
 		секция: сцена,
 		стрУрл: стрУрл,
 		клиент: сцена.Бот().Сеть().КлиентСеть(),
@@ -43,45 +39,45 @@ func НовСекцияСеть(сцена types.ИСценаСтр, стрУр
 	return сам, nil
 }
 
-// Обновляет список строк
-func (сам *СекцияСеть) ОбновитьСеть() (err error) {
+// Обновить -- обновляет список строк
+func (сам *СценаСеть) Обновить() error {
 	if сам == nil {
-		return
+		return fmt.Errorf("СценаСеть.Обновить(): нет объекта СценаСеть")
 	}
 	сам.блок.Lock()
 	defer сам.блок.Unlock()
 	// FIXME: попытка разобраться, что за фигня творится
 	// time.Sleep(time.Millisecond * 500)
-	log.Printf("СекцияСеть.ОбновитьСеть(): bot=%s\tsection=%v\n", сам.секция.Бот().Имя(), сам.секция.Имя())
+	log.Printf("СценаСеть.Обновить(): bot=%s\tsection=%v\n", сам.секция.Бот().Имя(), сам.секция.Имя())
 	if сам.секция.Имя() == "Арсенал" {
-		log.Printf("СекцияСеть.ОбновитьСеть(): арсенал\n")
+		log.Printf("СекцияСеть.Обновить(): арсенал\n")
 	}
 	lstString, err := сам.клиент.Get(сам.стрУрл)
 	if err != nil {
-		return fmt.Errorf("СекцияСеть.ОбновитьСеть(): in make request, err=\n\t%w", err)
+		return fmt.Errorf("СценаСеть.Обновить(): in make request, err=\n\t%w", err)
 	}
 	if err := сам.секция.СтрОбновить(lstString); err != nil {
-		return fmt.Errorf("СекцияСеть.ОбновитьСеть(): in update ISection, err=\n\t%w", err)
+		return fmt.Errorf("СценаСеть.Обновить(): in update ISection, err=\n\t%w", err)
 	}
 	return nil
 }
 
 // Get -- выполняет GET-запрос по указанному URL
-func (sf *СекцияСеть) Get(strLink string) (lstString []string, err error) {
+func (sf *СценаСеть) Get(strLink string) (lstString []string, err error) {
 	sf.блок.Lock()
 	defer sf.блок.Unlock()
-	// log._rintf("INFO СекцияСеть.Get(): link=%v\n", sf.strUrl)
+	// log._rintf("INFO СценаСеть.Get(): link=%v\n", sf.strUrl)
 	if !strings.Contains(strLink, sf.стрУрл) {
-		return nil, fmt.Errorf("СекцияСеть.Get(): strLink(%v) не содержит strUrl(%v)", strLink, sf.стрУрл)
+		return nil, fmt.Errorf("СценаСеть.Get(): strLink(%v) не содержит strUrl(%v)", strLink, sf.стрУрл)
 	}
 	lstString, err = sf.клиент.Get(strLink)
 	if err != nil {
-		return nil, fmt.Errorf("СекцияСеть.Get(): err=\n\t%v", err)
+		return nil, fmt.Errorf("СценаСеть.Get(): err=\n\t%v", err)
 	}
 	return lstString, nil
 }
 
 // Клиент -- возвращает хранимого клиента
-func (сам *СекцияСеть) Клиент() types.ИСетьКлиент {
+func (сам *СценаСеть) Клиент() types.ИСетьКлиент {
 	return сам.клиент
 }

pkg/components/section/section_mode/section_mode.go

@@ -1,50 +0,0 @@
-// package section_mode -- типовой режим секция работы части игры
-//
-//	Имеет имя режима и имя текущей работы в режиме
-package section_mode
-
-import (
-	"sync"
-)
-
-// SectionMode -- режим работы секции
-type SectionMode struct {
-	name  string // Имя режима
-	work  string // Имя работы
-	block sync.RWMutex
-}
-
-// NewSectionMode -- возвращает новый *SectionMode
-func NewSectionMode() *SectionMode {
-	return &SectionMode{
-		name: "start",
-	}
-}
-
-// Уст -- устанавливает режим работы
-func (sf *SectionMode) Уст(val string) {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	sf.name = val
-}
-
-// Получ -- возвращает хранимый режим работы
-func (sf *SectionMode) Получ() string {
-	sf.block.RLock()
-	defer sf.block.RUnlock()
-	return sf.name
-}
-
-// Режим -- возвращает хранимое имя работы
-func (sf *SectionMode) Режим() string {
-	sf.block.RLock()
-	defer sf.block.RUnlock()
-	return sf.work
-}
-
-// РежимУст -- устанавливает хранимое имя работы
-func (sf *SectionMode) РежимУст(work string) {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	sf.work = work
-}

pkg/components/section/zone/zone.go

@@ -1,59 +0,0 @@
-// package zone -- игровая зона (ангар, база, бан, битва и т.п.)
-package zone
-
-import (
-	"context"
-	"fmt"
-	"log"
-	"wartank/pkg/types"
-)
-
-// Зона -- игровая зона (ангар, база, бан, битва и т.п.)
-type Зона struct {
-	бот      types.ИБот // Ссылка на бота зоны
-	кнт      context.Context
-	фнОтмена func()
-	имя      string // Имя игровой зоны
-}
-
-// НовЗона -- возвращает новую игровую зону
-func НовЗона(бот types.ИБот, зонаИмя string) (*Зона, error) {
-	{ // Предусловия
-		if бот == nil {
-			return nil, fmt.Errorf("НовЗона(): IBot==nil")
-		}
-		if зонаИмя == "" {
-			return nil, fmt.Errorf("НовЗона(): zoneName is empty")
-		}
-	}
-	log.Printf("НовЗона(): name=%q\tzone=%q\n", бот.Имя(), зонаИмя)
-	кнт, fnCancel := context.WithCancel(бот.Кнт())
-	sf := &Зона{
-		бот:      бот,
-		имя:      зонаИмя,
-		кнт:      кнт,
-		фнОтмена: fnCancel,
-	}
-	_ = types.ИСцена(sf)
-	return sf, nil
-}
-
-// Кнт -- возвращает контекст игровой зоны
-func (sf *Зона) Кнт() context.Context {
-	return sf.кнт
-}
-
-// Закончить -- отменяет контекст игровой зоны
-func (sf *Зона) Закончить() {
-	sf.фнОтмена()
-}
-
-// Бот -- возвращает бота игровой зоны
-func (sf *Зона) Бот() types.ИБот {
-	return sf.бот
-}
-
-// Имя -- возвращает имя зоны
-func (sf *Зона) Имя() string {
-	return sf.имя
-}

pkg/cons/cons.go

@@ -1,40 +1,45 @@
 package cons
 
-import (
-	"wartank/pkg/alias"
-)
+import "wartank/pkg/alias"
 
 /*
 	Содержит константы для работы
 */
 
-const (
+const ( // Задержки для работы
 	Delay100   = 100 // Задержка в миллисекундах для битвы, сражения, войны
 	Delay500   = 500 // Задержка в миллисекундах для сражения (100 мсек -- слишком часто)
-	SelfName   = "WarTank"
+	СамИмя     = "WarTank"
 	ТопливоМин = 299 // Минимальное количество топлива
 )
 
-const (
-	TypeMsgResource = 1 // Тип сообщения -- ресурсы
-	TypeMsgArsenal  = 2 // Тип сообщения ресурсы
+const ( // Режимы работы
+	РежимНеСуществует = alias.СценаРежим("режим_не_существует")
+	РежимАпгрейд      = alias.СценаРежим("режим_апгрейд")
+	РежимОжидание     = alias.СценаРежим("режим_ожидание")
+	РежимРабота       = alias.СценаРежим("режим_работа")
 )
 
-const (
-	WinDefault alias.ОкноИмя = "winDefault"
-
-	WinConfig                 alias.ОкноИмя = "winConfig"                 // Режим конфигурирования
-	WinConfigServer           alias.ОкноИмя = "winConfigServer"           // Режим конфигуррования сервера
-	WinConfigServerHostInput  alias.ОкноИмя = "winConfigServerHostInput"  // Режим ввода хоста сервера
-	WinConfigServerLoginInput alias.ОкноИмя = "winConfigServerLoginInput" // Режим ввода логина на сервер
-	WinConfigServerPassInput  alias.ОкноИмя = "winConfigServerPassInput"  // Режим ввода пароля входа на сервер
-
-	WinServerConnect alias.ОкноИмя = "winServerConnect" // Режим подключения к серверу
-	WinServerLogin   alias.ОкноИмя = "winServerLogin"   // Режим логина на сервер
-
-	WinBotsMenu     alias.ОкноИмя = "winBotsMenu"     // Режим показа меню бото-фермы
-	WinBotsAddLogin alias.ОкноИмя = "winBotsAddLogin" // Добавление логина бота на бото-ферму
-	WinBotsAddPass  alias.ОкноИмя = "winBotsAddPass"  // Добавление пароля бота на бото-ферму
-	WinBotsList     alias.ОкноИмя = "winBotsLits"     // Список ботов на бото-ферме
-	WinBotShow      alias.ОкноИмя = "winBotShow"      // Показать состояние бота
-)
+// const (
+// 	TypeMsgResource = 1 // Тип сообщения -- ресурсы
+// 	TypeMsgArsenal  = 2 // Тип сообщения ресурсы
+// )
+
+// const (
+// 	WinDefault alias.ОкноИмя = "winDefault"
+
+// 	WinConfig                 alias.ОкноИмя = "winConfig"                 // Режим конфигурирования
+// 	WinConfigServer           alias.ОкноИмя = "winConfigServer"           // Режим конфигуррования сервера
+// 	WinConfigServerHostInput  alias.ОкноИмя = "winConfigServerHostInput"  // Режим ввода хоста сервера
+// 	WinConfigServerLoginInput alias.ОкноИмя = "winConfigServerLoginInput" // Режим ввода логина на сервер
+// 	WinConfigServerPassInput  alias.ОкноИмя = "winConfigServerPassInput"  // Режим ввода пароля входа на сервер
+
+// 	WinServerConnect alias.ОкноИмя = "winServerConnect" // Режим подключения к серверу
+// 	WinServerLogin   alias.ОкноИмя = "winServerLogin"   // Режим логина на сервер
+
+// 	WinBotsMenu     alias.ОкноИмя = "winBotsMenu"     // Режим показа меню бото-фермы
+// 	WinBotsAddLogin alias.ОкноИмя = "winBotsAddLogin" // Добавление логина бота на бото-ферму
+// 	WinBotsAddPass  alias.ОкноИмя = "winBotsAddPass"  // Добавление пароля бота на бото-ферму
+// 	WinBotsList     alias.ОкноИмя = "winBotsLits"     // Список ботов на бото-ферме
+// 	WinBotShow      alias.ОкноИмя = "winBotShow"      // Показать состояние бота
+// )

pkg/mock/mock_zone/mock_zone.go

@@ -1,33 +0,0 @@
-// package mock_zone -- мок-область зоны игры
-package mock_zone
-
-import (
-	"context"
-	"wartank/pkg/types"
-)
-
-// МокОбласть -- мок-область зоны игры
-type МокСцена struct {
-	кнт context.Context
-}
-
-func НовМокСцена() *МокСцена {
-	сам := &МокСцена{
-		кнт: context.Background(),
-	}
-	_ = types.ИСцена(сам)
-	return сам
-}
-
-func (сам *МокСцена) Кнт() context.Context {
-	return сам.кнт
-}
-
-func (сам *МокСцена) Имя() string {
-	return "МокСцена"
-}
-func (сам *МокСцена) Закончить() {}
-
-func (сам *МокСцена) Бот() types.ИБот {
-	return nil
-}

pkg/scene/scene.go

@@ -0,0 +1,63 @@
+// package scene -- базовая сцена для любой сцены
+package scene
+
+import (
+	"context"
+	"fmt"
+	"wartank/pkg/alias"
+	"wartank/pkg/scene/scene_mode"
+	"wartank/pkg/types"
+)
+
+type Сцена struct {
+	бот      types.ИБот
+	сценаИмя alias.СценаИмя
+	кнт      context.Context
+	фнОтмена func()
+	режим    types.ИСценаРежим
+}
+
+// НовСцена -- возвращает новую сцену
+func НовСцена(бот types.ИБот, сценаИмя alias.СценаИмя) (*Сцена, error) {
+	if бот == nil {
+		return nil, fmt.Errorf("НовСцена(): ИБот==nil")
+	}
+	if сценаИмя == "" {
+		return nil, fmt.Errorf("НовСцена(): сценаИмя не задано")
+	}
+	кнт, фнОтмена := context.WithCancel(бот.Кнт())
+	сам := &Сцена{
+		бот:      бот,
+		сценаИмя: сценаИмя,
+		кнт:      кнт,
+		фнОтмена: фнОтмена,
+		режим:    scene_mode.НовСценаРежим(),
+	}
+	_ = types.ИСцена(сам)
+	return сам, nil
+}
+
+// СценаРежим -- текущий режим работы
+func (сам *Сцена) СценаРежим() types.ИСценаРежим {
+	return сам.режим
+}
+
+// Отмена -- отменяет контекст сцены
+func (сам *Сцена) Отмена() {
+	сам.фнОтмена()
+}
+
+// Кнт -- возвращает контекст сцены
+func (сам *Сцена) Кнт() context.Context {
+	return сам.кнт
+}
+
+// Имя - -возвращает имя сцены
+func (сам *Сцена) Имя() alias.СценаИмя {
+	return сам.сценаИмя
+}
+
+// Бот -- возвращает бота сцены
+func (сам *Сцена) Бот() types.ИБот {
+	return сам.бот
+}

pkg/scene/scene_mode/scene_mode.go

@@ -0,0 +1,49 @@
+// package scene_mode -- типовой режим секция работы части игры
+package scene_mode
+
+import (
+	"sync"
+	"wartank/pkg/alias"
+)
+
+// СценаРежим -- режим работы секции
+type СценаРежим struct {
+	режимИмя  alias.СценаРежим  // Имя режима
+	работаИмя alias.СценаРабота // Имя работы
+	block     sync.RWMutex
+}
+
+// НовСекцияРежим -- возвращает новый *СценаРежим
+func НовСценаРежим() *СценаРежим {
+	return &СценаРежим{
+		режимИмя: "старт",
+	}
+}
+
+// РежимУст -- устанавливает режим работы
+func (сам *СценаРежим) РежимУст(val alias.СценаРежим) {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	сам.режимИмя = val
+}
+
+// Получ -- возвращает хранимый режим работы
+func (сам *СценаРежим) Режим() alias.СценаРежим {
+	сам.block.RLock()
+	defer сам.block.RUnlock()
+	return сам.режимИмя
+}
+
+// Работа -- возвращает хранимое имя работы
+func (сам *СценаРежим) Работа() alias.СценаРабота {
+	сам.block.RLock()
+	defer сам.block.RUnlock()
+	return сам.работаИмя
+}
+
+// РаботаУст -- устанавливает хранимое имя работы
+func (сам *СценаРежим) РаботаУст(работаИмя alias.СценаРабота) {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	сам.работаИмя = работаИмя
+}

pkg/components/section/section.go → pkg/section/section.go

@@ -8,36 +8,33 @@ import (
 
 	"wartank/pkg/alias"
 	"wartank/pkg/components/lst_string"
-	"wartank/pkg/components/section/down_time"
-	"wartank/pkg/components/section/section_mode"
-	"wartank/pkg/components/section/zone"
+	"wartank/pkg/scene"
+	"wartank/pkg/section/down_time"
 	"wartank/pkg/types"
 )
 
 // Секция -- секция игры
 type Секция struct {
-	*zone.Зона
+	*scene.Сцена
 	времяОстат types.ИВремяОстат     // Обратный отсчёт до окончания работы режима
-	режим      types.ИРежимРаботы    // Объект режима работы
 	списСтр    *lst_string.LstString // Список строк из сети для анализа секции
 	блок       sync.RWMutex
 }
 
 // НовСекция -- возвращает новую секцию игры
-func НовСекция(бот types.ИБот, зонаИмя, стрКонтроль string) (*Секция, error) {
+func НовСекция(бот types.ИБот, сценаИмя alias.СценаИмя, стрКонтроль string) (*Секция, error) {
 	log.Printf("НовСекция(): стрКонтроль=%q\n", стрКонтроль)
-	zone, err := zone.НовЗона(бот, зонаИмя)
-	if err != nil {
-		return nil, fmt.Errorf("НовСекция(): in create IZone, err=\n\t%w", err)
+	сцена, ош := scene.НовСцена(бот, сценаИмя)
+	if ош != nil {
+		return nil, fmt.Errorf("НовСекция(): при создании ИСцена, ош=\n\t%w", ош)
 	}
 	sf := &Секция{
-		Зона:       zone,
-		времяОстат: down_time.НовВремОбрат(zone, 5),
-		режим:      section_mode.NewSectionMode(),
+		Сцена:      сцена,
+		времяОстат: down_time.НовВремОбрат(сцена, 5),
 	}
-	sf.списСтр, err = lst_string.NewLstString(стрКонтроль)
-	if err != nil {
-		return nil, fmt.Errorf("НовСекция(): in create *LstString, err=\n\t%w", err)
+	sf.списСтр, ош = lst_string.NewLstString(стрКонтроль)
+	if ош != nil {
+		return nil, fmt.Errorf("НовСекция(): in create *LstString, err=\n\t%w", ош)
 	}
 	return sf, nil
 }
@@ -81,8 +78,3 @@ func (сам *Секция) ВремяОстат() types.ИВремяОстат
 	defer сам.блок.RUnlock()
 	return сам.времяОстат
 }
-
-// РежимТекущ -- текущий режим работы
-func (сам *Секция) РежимТекущ() types.ИРежимРаботы {
-	return сам.режим
-}

pkg/types/ibattle_action.go

@@ -14,7 +14,7 @@ import (
 type ИСражениеДействие interface {
 	ИСценаСтр
 	// Сеть -- возвращает сетевой компонент сражения
-	Сеть() ИСекцияСеть
+	Сеть() ИСценаСеть
 	// МанёврНадоУст -- устанавливает признак необходимости манёвра
 	МанёврНадоУст()
 	// ВыстрелБлок -- признак запрета на стрельбу

pkg/types/idiv_war_action.go

@@ -13,7 +13,7 @@ import (
 type ИДивизияВойнаДействие interface {
 	ИСценаСтр
 	// Сеть -- возвращает сетевой компонент сражения
-	Сеть() ИСекцияСеть
+	Сеть() ИСценаСеть
 	// IsEnd -- признак окончания сражения
 	// IsEnd() *isdivwar.IsDivWar
 	// Манёвр -- выполняет манёвр по требованию

pkg/types/imode.go

@@ -1,17 +0,0 @@
-package types
-
-/*
-	Режим работы секции.
-*/
-
-// ИРежимРаботы -- интерфейс к режиму работы секции
-type ИРежимРаботы interface {
-	// Уст -- устанавливает режим работы
-	Уст(string)
-	// Получ -- возвращает режим работы
-	Получ() string
-	// Режим -- возвращает имя текущей работы
-	Режим() string
-	// РежимУст -- устанавилвае тимя текущей работы
-	РежимУст(name string)
-}

pkg/types/iscene.go

@@ -1,6 +1,9 @@
 package types
 
-import "context"
+import (
+	"context"
+	"wartank/pkg/alias"
+)
 
 // ИСцена -- игровая сцена (ангар, база, битва и т.п.)
 type ИСцена interface {
@@ -8,8 +11,10 @@ type ИСцена interface {
 	Бот() ИБот
 	// Кнт -- контекст игровой зоны
 	Кнт() context.Context
-	// Закончить -- отмена контекста игровой сцены
-	Закончить()
+	// Отмена -- отмена контекста игровой сцены
+	Отмена()
 	// Имя -- имя игровой сцены
-	Имя() string
+	Имя() alias.СценаИмя
+	// СценаРежим -- текущий режим работы
+	СценаРежим() ИСценаРежим
 }

pkg/types/iscene_mode.go

@@ -0,0 +1,15 @@
+package types
+
+import "wartank/pkg/alias"
+
+// ИСценаРежим -- режим работы сцены
+type ИСценаРежим interface {
+	// РежимУст -- устанавливает режим работы сцены (не существует, ожидание, апгрейд. работа)
+	РежимУст(alias.СценаРежим)
+	// Режим -- возвращает режим работы сцены (не существует, ожидание, апгрейд, работа)
+	Режим() alias.СценаРежим
+	// Работа -- возвращает имя текущей работы (режим-1 или режим-2 если позволяет режим)
+	Работа() alias.СценаРабота
+	// РаботаИмяУст -- устанавилвает имя текущей работы(режим-1 или режим-2 если позволяет режим)
+	РаботаУст(name alias.СценаРабота)
+}

pkg/types/iscene_net.go

@@ -0,0 +1,8 @@
+package types
+
+// ИСценаСеть -- сетевыые операции сцены
+type ИСценаСеть interface {
+	// Обнновить -- обновляет список строк сцены из сети
+	Обновить() error
+	Get(strLink string) (lstString []string, err error)
+}

pkg/types/isection.go

@@ -13,6 +13,4 @@ type ИСценаСтр interface {
 	СписПолучить() []string
 	// ВремяОстат -- объект оставшегося времени до опроса сцены
 	ВремяОстат() ИВремяОстат
-	// РежимТекущ -- текущий режим работы
-	РежимТекущ() ИРежимРаботы
 }

server/serv_bots/warbot/angar/angar.go

@@ -8,7 +8,7 @@ import (
 	"strconv"
 	"strings"
 
-	"wartank/pkg/components/section"
+	"wartank/pkg/section"
 	"wartank/pkg/types"
 	"wartank/server/serv_bots/warbot/angar/angarnet"
 	"wartank/server/serv_bots/warbot/angar/base"
@@ -31,7 +31,7 @@ import (
 // Ангар -- ангар для танка
 type Ангар struct {
 	*section.Секция
-	сеть       *angarnet.AngarNet
+	сеть       types.ИСценаСеть
 	топливоБой *fuel_attack.ТопливоБой
 
 	бот      types.ИБот
@@ -190,7 +190,7 @@ func (sf *Ангар) Пуск() error {
 		sf.Обновить()
 		// sf.конвойПроверить()
 		if err := sf.Секция.ОбратВремяУст("01:00"); err != nil {
-			sf.Закончить()
+			sf.Отмена()
 			logrus.WithError(err).Errorln("Ангар.Run(): in update ICountTime")
 			return false
 		}
@@ -218,13 +218,13 @@ func (sf *Ангар) Пуск() error {
 }
 
 // Обновляет ресурсы ангара
-func (sf *Ангар) РесурсыОбновить() {
-	if err := sf.сеть.ОбновитьСеть(); err != nil {
+func (сам *Ангар) РесурсыОбновить() {
+	if ош := сам.сеть.Обновить(); ош != nil {
 		// log._rintf("ERRO Ангар.updateResurs(): при обработке ангара в сети, err=\n\t%v\n", err)
 		return
 	}
-	sf.золотоНайти()
-	sf.сереброНайти()
+	сам.золотоНайти()
+	сам.сереброНайти()
 }
 
 // IMissions -- возвращает ссылку на объект миссий

server/serv_bots/warbot/angar/angarnet/angarnet.go

@@ -3,7 +3,7 @@ package angarnet
 import (
 	"fmt"
 
-	"wartank/pkg/components/section_net"
+	"wartank/pkg/components/scene_net"
 	"wartank/pkg/types"
 )
 
@@ -13,21 +13,21 @@ import (
 
 // AngarNet -- объект сетевого ангара
 type AngarNet struct {
-	*section_net.СекцияСеть
+	*scene_net.СценаСеть
 	angar types.ИАнгар
 }
 
 // NewAngarNet -- возвращает новый *AngarNet
 func NewAngarNet(angar types.ИАнгар) (*AngarNet, error) {
-	sectionNet, err := section_net.НовСекцияСеть(angar, "https://wartank.ru/angar")
+	sectionNet, err := scene_net.НовСекцияСеть(angar, "https://wartank.ru/angar")
 	if err != nil {
 		return nil, fmt.Errorf("NewAngarNet(): in create *SectionNet, err=\n\t%w", err)
 	}
 
-	sf := &AngarNet{
-		СекцияСеть: sectionNet,
-		angar:      angar,
+	сам := &AngarNet{
+		СценаСеть: sectionNet,
+		angar:     angar,
 	}
-
-	return sf, nil
+	_ = types.ИСценаСеть(сам)
+	return сам, nil
 }

server/serv_bots/warbot/angar/base/arsenal/arsenal.go

@@ -7,7 +7,7 @@ import (
 	"strings"
 	"time"
 
-	"wartank/pkg/components/section"
+	"wartank/pkg/section"
 	"wartank/pkg/types"
 	"wartank/server/serv_bots/warbot/angar/base/arsenal/arsenalnet"
 	"wartank/server/serv_bots/warbot/tank/tankstat/static_param"
@@ -281,8 +281,8 @@ func (сам *Оружейная) Ремки() types.ИСтатПарам {
 // Обновляет состояние арсенала по требованию
 func (сам *Оружейная) СтатаОбновить() (err error) {
 	// _mt.Println("\tArsenalNet.updateArsenal()")
-	if err := сам.сеть.ОбновитьСеть(); err != nil {
-		return fmt.Errorf("Оружейная.Обновить(): при обновлении lstArsenal, err=%w", err)
+	if ош := сам.сеть.Обновить(); ош != nil {
+		return fmt.Errorf("Оружейная.СтатаОбновить(): при обновлении lstArsenal, err=%w", ош)
 	}
 	var (
 		strOut     string
@@ -361,8 +361,8 @@ func (сам *Оружейная) СтатаОбновить() (err error) {
 
 // Выбирает что надо делать, запускает процесс изготовления
 func (сам *Оружейная) сделать() bool {
-	err := сам.сеть.ОбновитьСеть()
-	if err != nil {
+	ош := сам.сеть.Обновить()
+	if ош != nil {
 		// log._rintf("ERRO Оружейная.сделать(): при обновлении lstArsenal, err=\n\t%v\n", err)
 		return false
 	}
@@ -435,7 +435,7 @@ func (сам *Оружейная) сделатьБронебойки() {
 		// log._rintf("ERRO ArsenalNet.makeArmor(): in update lstArsenal,  err=\n\t%v\n", err)
 		return
 	}
-	сам.РежимТекущ().РежимУст(стрБронебойки)
+	сам.СценаРежим().РежимУст(стрБронебойки)
 }
 
 // Создать кумулятивные
@@ -469,7 +469,7 @@ func (сам *Оружейная) сделатьКумули() {
 		// log._rintf("ERRO ArsenalNet.makeKumul(): in make product arsenal kumul , err=\n\t%v\n", err)
 		return
 	}
-	сам.РежимТекущ().РежимУст(стрКумулятивы)
+	сам.СценаРежим().РежимУст(стрКумулятивы)
 }
 
 // Создать фугасы
@@ -503,7 +503,7 @@ func (сам *Оружейная) сдлатьФугасы() {
 		// log._rintf("ERRO ArsenalNet.makeFugas(): in make request arsenal product, err=\n\t%v\n", err)
 		return
 	}
-	сам.РежимТекущ().РежимУст(стрФугасы)
+	сам.СценаРежим().РежимУст(стрФугасы)
 	// log._rintf("INFO Оружейная.makeFugas()\n")
 }
 
@@ -538,6 +538,6 @@ func (сам *Оружейная) сделатьРемку() bool {
 		log.Printf("Оружейная.сделатьРемку(): при отдаче команды сделать ремку, err=\n\t%v\n", err)
 		return false
 	}
-	сам.РежимТекущ().РежимУст(стрРемки)
+	сам.СценаРежим().РежимУст(стрРемки)
 	return true
 }

server/serv_bots/warbot/angar/base/arsenal/arsenalnet/arsenalnet.go

@@ -3,7 +3,7 @@ package arsenalnet
 import (
 	"fmt"
 
-	"wartank/pkg/components/section_net"
+	"wartank/pkg/components/scene_net"
 	"wartank/pkg/types"
 )
 
@@ -13,18 +13,18 @@ import (
 
 // ArsenalNet -- планировщик беоприпасов и ремок в сети
 type ArsenalNet struct {
-	*section_net.СекцияСеть
+	*scene_net.СценаСеть
 }
 
 // НовАрсеналСеть -- возвращает новый *ArsenalNet
 func НовАрсеналСеть(arsenal types.ИАрсенал) (*ArsenalNet, error) {
-	sectionNet, err := section_net.НовСекцияСеть(arsenal, "https://wartank.ru/production/Armory")
+	sectionNet, err := scene_net.НовСекцияСеть(arsenal, "https://wartank.ru/production/Armory")
 	if err != nil {
 		return nil, fmt.Errorf("NewArsenalNet(): in create SectionNet, err=\n\t%w", err)
 	}
 
 	sf := &ArsenalNet{
-		СекцияСеть: sectionNet,
+		СценаСеть: sectionNet,
 	}
 
 	return sf, nil

server/serv_bots/warbot/angar/base/bank/bank.go

@@ -8,7 +8,7 @@ import (
 	"time"
 
 	"wartank/pkg/alias"
-	"wartank/pkg/components/section"
+	"wartank/pkg/section"
 	"wartank/pkg/types"
 	"wartank/server/serv_bots/warbot/angar/base/bank/bankmode"
 	"wartank/server/serv_bots/warbot/angar/base/bank/banknet"
@@ -61,7 +61,7 @@ func (сам *Банк) Пуск() error {
 
 // UpdateLst -- принудительно обновляет состояние банка
 func (сам *Банк) UpdateLst() {
-	if err := сам.сеть.ОбновитьСеть(); err != nil {
+	if err := сам.сеть.Обновить(); err != nil {
 		log.Printf("Банк.UpdateLst(): err=\n\t%v\n", err)
 	}
 }
@@ -79,7 +79,7 @@ func (сам *Банк) пуск() {
 			time.Sleep(time.Minute * 30)
 			return
 		}
-		if ош := сам.сеть.ОбновитьСеть(); ош != nil {
+		if ош := сам.сеть.Обновить(); ош != nil {
 			// log._rintf("ERRO Банк.пуск():  при обновлении lstBank, err=\n\t%v\n", err)
 			return
 		}

server/serv_bots/warbot/angar/base/bank/banknet/banknet.go

@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"log"
 
-	"wartank/pkg/components/section_net"
+	"wartank/pkg/components/scene_net"
 	"wartank/pkg/types"
 )
 
@@ -14,19 +14,19 @@ import (
 
 // BankNet -- обзор базы
 type BankNet struct {
-	*section_net.СекцияСеть
+	*scene_net.СценаСеть
 }
 
 // NewBankNet -- возвращает новый *BankNet
 func NewBankNet(bank types.ИБанк) (*BankNet, error) {
 	log.Printf("NewBankNet()\n")
-	sectionNet, err := section_net.НовСекцияСеть(bank, "https://wartank.ru/production/Bank")
+	sectionNet, err := scene_net.НовСекцияСеть(bank, "https://wartank.ru/production/Bank")
 	if err != nil {
 		return nil, fmt.Errorf("NewBankNet(): in create *SectionNet, err=\n\t%w", err)
 	}
 
 	sf := &BankNet{
-		СекцияСеть: sectionNet,
+		СценаСеть: sectionNet,
 	}
 
 	return sf, nil

server/serv_bots/warbot/angar/base/base.go

@@ -9,7 +9,8 @@ import (
 	"time"
 
 	"wartank/pkg/alias"
-	"wartank/pkg/components/section"
+	"wartank/pkg/cons"
+	"wartank/pkg/section"
 	"wartank/pkg/types"
 	"wartank/server/serv_bots/warbot/angar/base/arsenal"
 	"wartank/server/serv_bots/warbot/angar/base/bank"
@@ -102,24 +103,24 @@ func (sf *База) Пуск() error {
 }
 
 // Собственная работа
-func (sf *База) пуск() {
+func (сам *База) пуск() {
 	фнЦикл := func() {
 		defer time.Sleep(time.Minute * 2)
-		if err := sf.сеть.ОбновитьСеть(); err != nil { // Обновить состояние базы
-			log.Printf("ERRO Base.Run(): при обновлении базы, err=\n\t%v\n", err)
+		if ош := сам.сеть.Обновить(); ош != nil { // Обновить состояние базы
+			log.Printf("ERRO Base.Run(): при обновлении базы, err=\n\t%v\n", ош)
 		}
-		sf.проверитьПолигонУсиление()              // Проверить усиление полигона
-		if err := sf.проверитьБанк(); err != nil { // Проверка режимов банка
+		сам.проверитьПолигонУсиление()              // Проверить усиление полигона
+		if err := сам.проверитьБанк(); err != nil { // Проверка режимов банка
 			log.Printf("ERRO Base.Run(): при проверке банка, err=\n\t%v\n", err)
 		}
-		sf.проверитьАрсенал() // Проверка арсенала
-		sf.проверитьШахту()   // Проверка шахты
-		sf.setCountDown()     // Установка счётчика времени
+		сам.проверитьАрсенал() // Проверка арсенала
+		сам.проверитьШахту()   // Проверка шахты
+		сам.setCountDown()     // Установка счётчика времени
 
 	}
 	for {
 		select {
-		case <-sf.Кнт().Done():
+		case <-сам.Кнт().Done():
 			return
 		// case <-sf.ВремяОпрос().КаналСиг():
 		// 	фнЦикл()
@@ -207,7 +208,7 @@ func (sf *База) проверитьШахту() {
 		sf.шахтаСтатаОбновить()
 	}
 	sf.шахтаАпгрейдФорсаж() // Нужно ли ускорить апгрейд шахты
-	if sf.шахта.РежимТекущ().Получ() == "upgrade" {
+	if sf.шахта.СценаРежим().Режим() == "upgrade" {
 		return
 	}
 	sf.шахтаСтатаОбновить()
@@ -366,19 +367,22 @@ func (sf *База) шахтаСтатаОбновить() {
 			strNum := lstNum[1]
 			lstNum = strings.Split(strNum, `</div></td>`)
 			strNum = lstNum[0]
-			sf.шахта.РежимТекущ().РежимУст("Железо-" + strNum)
+			работа := alias.СценаРабота("Железо-" + strNum)
+			sf.шахта.СценаРежим().РаботаУст(работа)
 		case strings.Contains(strOut, `/images/icons/ore.png`): // Руда
 			lstNum := strings.Split(strOut, `<td class="vam"><div class="nwr pr5 gray1"><img class="rico vm" src="/images/icons/ore.png?2" alt="ore"/>&nbsp;`)
 			strNum := lstNum[1]
 			lstNum = strings.Split(strNum, `</div></td>`)
 			strNum = lstNum[0]
-			sf.шахта.РежимТекущ().РежимУст("Руда-" + strNum)
+			работа := alias.СценаРабота("Руда-" + strNum)
+			sf.шахта.СценаРежим().РаботаУст(работа)
 		case strings.Contains(strOut, `/images/icons/steel.png`): // Руда
 			lstNum := strings.Split(strOut, `<td class="vam"><div class="nwr pr5 gray1"><img class="rico vm" src="/images/icons/steel.png?2" alt="steel"/>&nbsp;`)
 			strNum := lstNum[1]
 			lstNum = strings.Split(strNum, `</div></td>`)
 			strNum = lstNum[0]
-			sf.шахта.РежимТекущ().РежимУст("Сталь-" + strNum)
+			работа := alias.СценаРабота("Сталь-" + strNum)
+			sf.шахта.СценаРежим().РаботаУст(работа)
 		}
 	}
 }
@@ -393,11 +397,11 @@ func (sf *База) проверитьАрсенал() {
 		// log._rintf("ERRO Base.checkArsenal(): при обновлении арсенала, err=\n\t%v\n", err)
 		return
 	}
-	if mode := sf.арсенал.РежимТекущ().Режим(); mode == "" {
+	if работа := sf.арсенал.СценаРежим().Работа(); работа == "" {
 		sf.проверитьАрсеналРежим()
 	}
 	sf.проверитьАрсеналУскорение() // Нужно ли ускорить апгрейд арсенала
-	if sf.арсенал.РежимТекущ().Получ() == "upgrade" {
+	if sf.арсенал.СценаРежим().Режим() == cons.РежимАпгрейд {
 		return
 	}
 	sf.проверитьАрсеналВремя()
@@ -447,19 +451,19 @@ func (sf *База) проверитьАрсеналРежим() {
 	)
 	for _, strOut = range lstBase {
 		if strings.Contains(strOut, `HollowCharge.png`) {
-			sf.арсенал.РежимТекущ().РежимУст("кумулятивы")
+			sf.арсенал.СценаРежим().РежимУст("кумулятивы")
 			return
 		}
 		if strings.Contains(strOut, `ArmorPiercing.png`) {
-			sf.арсенал.РежимТекущ().РежимУст("бронебойки")
+			sf.арсенал.СценаРежим().РежимУст("бронебойки")
 			return
 		}
 		if strings.Contains(strOut, `HighExplosive.png`) {
-			sf.арсенал.РежимТекущ().РежимУст("фугасы")
+			sf.арсенал.СценаРежим().РежимУст("фугасы")
 			return
 		}
 		if strings.Contains(strOut, `repairkit.gif`) {
-			sf.арсенал.РежимТекущ().РежимУст("ремки")
+			sf.арсенал.СценаРежим().РежимУст("ремки")
 			return
 		}
 	}
@@ -491,8 +495,8 @@ func (sf *База) проверитьАрсеналУскорение() {
 				if err := sf.арсенал.ОбратВремяУст(времОжидПлат); err != nil {
 					log.Printf("WARN Base.checkArsenalForce(): при установке платного времени ускорения апгрейда арсенала(%v)\n\terr=%v\n", времОжидПлат, err)
 				}
-				sf.арсенал.РежимТекущ().Уст("upgrade")
-				sf.арсенал.РежимТекущ().РежимУст("апгрейд")
+				sf.арсенал.СценаРежим().РаботаУст("апгрейд")
+				sf.арсенал.СценаРежим().РежимУст(cons.РежимАпгрейд)
 				return
 			}
 		}
@@ -514,7 +518,7 @@ func (sf *База) проверитьАрсеналУскорение() {
 		if !strings.Contains(strOut, `>Ускорение<`) {
 			return
 		}
-		sf.арсенал.РежимТекущ().Уст("upgrade")
+		sf.арсенал.СценаРежим().РежимУст(cons.РежимАпгрейд)
 		lstLink := strings.Split(strOut, `<td style="width:50%;padding-left:1px;"><a class="simple-but border" href="`)
 		strLink := lstLink[1]
 		lstLink = strings.Split(strLink, `"><span><span>Ускорение</span></span></a>`)
@@ -529,19 +533,19 @@ func (sf *База) проверитьАрсеналУскорение() {
 			// log._rintf("ERRO NetBank.checkArsenalForce(): при обновлении lstBase, err=\n\t%v\n", err)
 			return
 		}
-		sf.арсенал.РежимТекущ().Уст("upgrade")
-		sf.арсенал.РежимТекущ().РежимУст("апгрейд")
+		sf.арсенал.СценаРежим().РаботаУст("апгрейд")
+		sf.арсенал.СценаРежим().РежимУст(cons.РежимАпгрейд)
 		if err := sf.арсенал.ОбратВремяУст(времОжидБесплат); err != nil {
 			log.Printf("WARN Base.checkArsenalForce(): при установке бесплатного времени ускорения апгрейда арсенала(%v)\n\terr=%v\n", времОжидБесплат, err)
 		}
 	}
 	// Все проверки прошли -- это просто работа
-	sf.арсенал.РежимТекущ().Уст("work")
+	sf.арсенал.СценаРежим().РежимУст(cons.РежимРабота)
 }
 
 // Проверяет режим банка
 func (sf *База) проверитьБанк() error {
-	if sf.банк.РежимТекущ().Режим() == "" {
+	if sf.банк.СценаРежим().Работа() == "" {
 		sf.checkBankMode()
 	}
 	sf.checkBankTime() // Проверка времени ожидания
@@ -550,7 +554,7 @@ func (sf *База) проверитьБанк() error {
 		return nil
 	}
 	sf.checkBankForce() // Нужно ли ускорить апгрейд банка
-	if sf.банк.РежимТекущ().Получ() == "upgrade" {
+	if sf.банк.СценаРежим().Режим() == cons.РежимАпгрейд {
 		return nil
 	}
 	sf.checkBankProduct() // Запуск производства в  банке
@@ -558,11 +562,11 @@ func (sf *База) проверитьБанк() error {
 }
 
 // Проверяет режим работы банка
-func (sf *База) checkBankMode() {
+func (сам *База) checkBankMode() {
 	var (
 		strOut  string
 		isFind  bool
-		lstBase = sf.СписПолучить()
+		lstBase = сам.СписПолучить()
 	)
 	for _, strOut = range lstBase {
 		if strings.Contains(strOut, `<td class="vam"><div class="nwr pr5 gray1"><img class="rico vm" src="/images/icons/silver.png?2" alt="silver"/>&nbsp;`) {
@@ -576,8 +580,9 @@ func (sf *База) checkBankMode() {
 	lstSilver := strings.Split(strOut, `<td class="vam"><div class="nwr pr5 gray1"><img class="rico vm" src="/images/icons/silver.png?2" alt="silver"/>&nbsp;`)
 	strSilver := lstSilver[1]
 	lstSilver = strings.Split(strSilver, `</div></td>`)
-	strSilver = "Серебро-" + lstSilver[0]
-	sf.банк.РежимТекущ().РежимУст(strSilver)
+	работа := alias.СценаРабота("Серебро-" + lstSilver[0])
+	сам.банк.СценаРежим().РаботаУст(работа)
+	сам.банк.СценаРежим().РежимУст(cons.РежимРабота)
 
 }
 
@@ -662,8 +667,8 @@ func (sf *База) checkBankForce() {
 			if err := sf.банк.ОбратВремяУст(времОжидПлат); err != nil {
 				log.Printf("WARN Base.checkBankForce(): при установке времени ожидания платного ускорения апгрейда банка(%v)\n\terr=%v\n", времОжидПлат, err)
 			}
-			sf.банк.РежимТекущ().Уст("upgrade")
-			sf.банк.РежимТекущ().РежимУст("апгрейд")
+			sf.банк.СценаРежим().РаботаУст("апгрейд")
+			sf.банк.СценаРежим().РежимУст(cons.РежимАпгрейд)
 			return
 		}
 	}
@@ -693,8 +698,8 @@ func (sf *База) checkBankForce() {
 				// log._rintf("ERRO NetBank.checkBankForce(): при обновлении lstBase, err=\n\t%v\n", err)
 				return
 			}
-			sf.банк.РежимТекущ().Уст("upgrade")
-			sf.банк.РежимТекущ().РежимУст("апгрейд")
+			sf.банк.СценаРежим().РаботаУст("апгрейд")
+			sf.банк.СценаРежим().РежимУст(cons.РежимАпгрейд)
 			if err := sf.банк.ОбратВремяУст(времОжидБесплат); err != nil {
 				log.Printf("WARN Base.checkBankForce(): при установке времени бесплатного ускорения агрейда банка(%v)\n\terr=%v\n", времОжидБесплат, err)
 			}
@@ -721,8 +726,8 @@ func (sf *База) шахтаАпгрейдФорсаж() {
 			}
 		}
 		if isOut && strings.Contains(strOut, `Ускорить за`) {
-			sf.шахта.РежимТекущ().Уст("upgrade")
-			sf.шахта.РежимТекущ().РежимУст("апгрейд")
+			sf.шахта.СценаРежим().РаботаУст("апгрейд")
+			sf.шахта.СценаРежим().РежимУст(cons.РежимАпгрейд)
 			if err := sf.шахта.ОбратВремяУст(времОжидПлат); err != nil {
 				log.Printf("WARN Base.checkMineForce(): при установке времени платного апгрейда шахты(%v)\n\terr=%v\n", времОжидПлат, err)
 			}
@@ -758,13 +763,13 @@ func (sf *База) шахтаАпгрейдФорсаж() {
 				log.Printf("WARN Base.checkMineForce(): при установке времени апгрейда шахты(%v)\n\terr=%v\n", времОжидБесплат, err)
 			}
 			// sound.MineForce()
-			sf.шахта.РежимТекущ().Уст("upgrade")
-			sf.шахта.РежимТекущ().РежимУст("апгрейд")
+			sf.шахта.СценаРежим().РаботаУст("апгрейд")
+			sf.шахта.СценаРежим().РежимУст(cons.РежимАпгрейд)
 			return
 		}
 	}
 	// Все проверки прошли -- это просто работа
-	sf.шахта.РежимТекущ().Уст("work")
+	sf.шахта.СценаРежим().РежимУст(cons.РежимРабота)
 }
 
 // Проверяет на ускорение апгрейда полигона
@@ -798,8 +803,8 @@ func (sf *База) проверитьПолигонУсиление() {
 			// if err := sf.polygon.CountDown().Set(strTime); err != nil {
 			// 	// log._rintf("WARN Base.checkMineForce(): при установке времени апгрейда полигона(%v)\n\terr=%v\n", strTime, err)
 			// }
-			sf.полигон.РежимТекущ().Уст("upgrade")
-			sf.полигон.РежимТекущ().РежимУст("апгрейд")
+			sf.полигон.СценаРежим().РаботаУст("апгрейд")
+			sf.полигон.СценаРежим().РежимУст(cons.РежимАпгрейд)
 			if err := sf.полигон.ОбратВремяУст(времОжидПлат); err != nil {
 				log.Printf("WARN Base.checkPolygonForce(): при установке платного времени апгрейда полигона(%v)\n\terr=%v\n", времОжидПлат, err)
 			}
@@ -832,8 +837,8 @@ func (sf *База) проверитьПолигонУсиление() {
 				return
 			}
 			// sound.MineForce()
-			sf.полигон.РежимТекущ().Уст("upgrade")
-			sf.полигон.РежимТекущ().РежимУст("апгрейд")
+			sf.полигон.СценаРежим().РаботаУст("апгрейд")
+			sf.полигон.СценаРежим().РежимУст(cons.РежимАпгрейд)
 			// Установить время ожидания для обновления
 			if err := sf.полигон.ОбратВремяУст(времОжидБесплат); err != nil {
 				log.Printf("WARN Base.checkPolygonForce(): при установке времени бесплатного апгрейда полигона(%v)\n\terr=%v\n", времОжидБесплат, err)
@@ -843,5 +848,5 @@ func (sf *База) проверитьПолигонУсиление() {
 		}
 	}
 	// Все проверки прошли -- это просто работа
-	sf.полигон.РежимТекущ().Уст("work")
+	sf.полигон.СценаРежим().РежимУст(cons.РежимРабота)
 }

server/serv_bots/warbot/angar/base/basenet/basenet.go

@@ -3,7 +3,7 @@ package basenet
 import (
 	"fmt"
 
-	"wartank/pkg/components/section_net"
+	"wartank/pkg/components/scene_net"
 	"wartank/pkg/types"
 )
 
@@ -13,21 +13,21 @@ import (
 
 // BaseNet -- обзор базы
 type BaseNet struct {
-	*section_net.СекцияСеть
+	*scene_net.СценаСеть
 	strUrl string
 }
 
 // NewBaseNet -- возвращает новый *BaseNet
 func NewBaseNet(base types.ИБаза) (*BaseNet, error) {
 	strUrl := "https://wartank.ru/buildings"
-	sectionNet, err := section_net.НовСекцияСеть(base, strUrl)
+	sectionNet, err := scene_net.НовСекцияСеть(base, strUrl)
 	if err != nil {
 		return nil, fmt.Errorf("NewBaseNet(): in create SectionNet, err=\n\t%w", err)
 	}
 
 	sf := &BaseNet{
-		СекцияСеть: sectionNet,
-		strUrl:     strUrl,
+		СценаСеть: sectionNet,
+		strUrl:    strUrl,
 	}
 	return sf, nil
 }

server/serv_bots/warbot/angar/base/market/market.go

@@ -7,7 +7,7 @@ import (
 	"time"
 
 	"wartank/pkg/alias"
-	"wartank/pkg/components/section"
+	"wartank/pkg/section"
 	"wartank/pkg/types"
 	"wartank/server/serv_bots/warbot/angar/base/market/marketnet"
 )
@@ -77,8 +77,8 @@ func (сам *Рынок) проверОжидание() {
 	)
 	// countDown := sf.CountDown().Get()
 	фнЕслиСеребро := func() bool { // Найти счётчик цены серебра
-		if err := сам.сеть.ОбновитьСеть(); err != nil { // Принудительное ПЕРВОЕ обновление рынка
-			log.Printf("Market.checkTime(): при обновлении lstMarket, err=\n\t%v\n", err)
+		if ош := сам.сеть.Обновить(); ош != nil { // Принудительное ПЕРВОЕ обновление рынка
+			log.Printf("Market.checkTime(): при обновлении lstMarket, err=\n\t%v\n", ош)
 			return false
 		}
 		isFind := false

server/serv_bots/warbot/angar/base/market/marketnet/marketnet.go

@@ -3,7 +3,7 @@ package marketnet
 import (
 	"fmt"
 
-	"wartank/pkg/components/section_net"
+	"wartank/pkg/components/scene_net"
 	"wartank/pkg/types"
 )
 
@@ -13,18 +13,18 @@ import (
 
 // MarketNet -- обзор рынка
 type MarketNet struct {
-	*section_net.СекцияСеть
+	*scene_net.СценаСеть
 }
 
 // NewMarketNet -- возвращает новый *MarketNet
 func NewMarketNet(market types.ИРынок) (*MarketNet, error) {
-	sectionNet, err := section_net.НовСекцияСеть(market, "https://wartank.ru/market")
+	sectionNet, err := scene_net.НовСекцияСеть(market, "https://wartank.ru/market")
 	if err != nil {
 		return nil, fmt.Errorf("NewMarketNet(): in create *SectionNet, err=\n\t%w", err)
 	}
 
 	sf := &MarketNet{
-		СекцияСеть: sectionNet,
+		СценаСеть: sectionNet,
 	}
 
 	return sf, nil

server/serv_bots/warbot/angar/base/mine/mine.go

@@ -9,7 +9,7 @@ import (
 	"time"
 
 	"wartank/pkg/alias"
-	"wartank/pkg/components/section"
+	"wartank/pkg/section"
 	"wartank/pkg/types"
 	"wartank/server/serv_bots/warbot/angar/base/mine/minenet"
 	"wartank/server/serv_bots/warbot/tank/tankstat/static_param"
@@ -326,8 +326,8 @@ func (сам *Шахта) построить(списСтр []string) {
 
 // Сделать -- вызывается с базы, если она обнаружила, что пора сделать продукцию
 func (сам *Шахта) Сделать() {
-	if err := сам.сеть.ОбновитьСеть(); err != nil {
-		log.Printf("ERRO Шахта.Сделать(): при обновлении lstMine, err=\n\t%v\n", err)
+	if ош := сам.сеть.Обновить(); ош != nil {
+		log.Printf("ERRO Шахта.Сделать(): при обновлении lstMine, err=\n\t%v\n", ош)
 		return
 	}
 	if !сам.уровеньОбновить() {
@@ -337,7 +337,7 @@ func (сам *Шахта) Сделать() {
 		log.Printf("ERRO Шахта.Сделать(): при выборе продукции, err=\n\t%v\n", err)
 		return
 	}
-	работа := сам.РежимТекущ().Режим()
+	работа := сам.СценаРежим().Работа()
 	switch работа {
 	case "руда":
 		сам.рудаСделать()
@@ -427,26 +427,26 @@ func (сам *Шахта) выбратьМеталл() error {
 		}
 	}
 	фнВыбратьПродукт()
-	сам.РежимТекущ().РежимУст("руда")
+	сам.СценаРежим().РаботаУст("руда")
 	руда := сам.Руда().Получ()
 	железо := сам.Железо().Получ()
 	if диктПродукция["железо"] {
 		if руда > железо*2 {
-			сам.РежимТекущ().РежимУст("железо")
+			сам.СценаРежим().РаботаУст("железо")
 		}
 	}
 
 	сталь := сам.Сталь().Получ()
 	if диктПродукция["сталь"] {
 		if железо > сталь*2 {
-			сам.РежимТекущ().РежимУст("сталь")
+			сам.СценаРежим().РаботаУст("сталь")
 		}
 	}
 
 	свинец := сам.Свинец().Получ()
 	if диктПродукция["свинец"] {
 		if сталь > свинец*2 {
-			сам.РежимТекущ().РежимУст("свинец")
+			сам.СценаРежим().РаботаУст("свинец")
 		}
 	}
 

server/serv_bots/warbot/angar/base/mine/minenet/minenet.go

@@ -2,7 +2,7 @@ package minenet
 
 import (
 	"fmt"
-	"wartank/pkg/components/section_net"
+	"wartank/pkg/components/scene_net"
 	"wartank/pkg/types"
 )
 
@@ -12,17 +12,17 @@ import (
 
 // MineNet -- опрашивает шахту на базе
 type MineNet struct {
-	*section_net.СекцияСеть
+	*scene_net.СценаСеть
 }
 
 // NewMineNet -- возвращает новый *MineNet
 func NewMineNet(mine types.ИБазаШахта) (*MineNet, error) {
-	sectionNet, err := section_net.НовСекцияСеть(mine, "https://wartank.ru/production/Mine")
+	sectionNet, err := scene_net.НовСекцияСеть(mine, "https://wartank.ru/production/Mine")
 	if err != nil {
 		return nil, fmt.Errorf("NewMineNet(): in create *SectionNet, err=\n\t%w", err)
 	}
 	sf := &MineNet{
-		СекцияСеть: sectionNet,
+		СценаСеть: sectionNet,
 	}
 	return sf, nil
 }

server/serv_bots/warbot/angar/base/polygon/polygon.go

@@ -9,7 +9,8 @@ import (
 	"wartank/pkg/alias"
 	"wartank/pkg/components/safe_int"
 	"wartank/pkg/components/safe_string"
-	"wartank/pkg/components/section"
+	"wartank/pkg/cons"
+	"wartank/pkg/section"
 	"wartank/pkg/types"
 	"wartank/server/serv_bots/warbot/angar/base/polygon/polygonnet"
 	"wartank/server/serv_bots/warbot/tank/tankstat/static_param"
@@ -137,8 +138,8 @@ func (сам *Полигон) проверитьУскорение() {
 			if err := сам.ОбратВремяУст(времОжидПлат); err != nil {
 				log.Printf("WARN Base.checkArsenalForce(): при установке платного времени ускорения апгрейда арсенала(%v)\n\terr=%v\n", времОжидПлат, err)
 			}
-			сам.РежимТекущ().Уст(стрАпгрейд)
-			сам.РежимТекущ().РежимУст(стрАпгрейд)
+			сам.СценаРежим().РаботаУст(стрАпгрейд)
+			сам.СценаРежим().РежимУст(cons.РежимАпгрейд)
 			сам.продуктСейчас.Уст(стрАпгрейд)
 			сам.продуктКол.Уст(0)
 			return
@@ -159,7 +160,7 @@ func (сам *Полигон) проверитьУскорение() {
 		if !strings.Contains(strOut, `>Ускорение<`) {
 			return
 		}
-		сам.РежимТекущ().Уст(стрАпгрейд)
+		сам.СценаРежим().РежимУст(cons.РежимАпгрейд)
 		сам.продуктСейчас.Уст(стрАпгрейд)
 		сам.продуктКол.Уст(0)
 		lstLink := strings.Split(strOut, `<td style="width:50%;padding-left:1px;"><a class="simple-but border" href="`)
@@ -176,15 +177,15 @@ func (сам *Полигон) проверитьУскорение() {
 			// log._rintf("ERRO NetBank.checkArsenalForce(): при обновлении lstBase, err=\n\t%v\n", err)
 			return
 		}
-		сам.РежимТекущ().Уст(стрАпгрейд)
-		сам.РежимТекущ().РежимУст(стрАпгрейд)
+		сам.СценаРежим().РаботаУст(стрАпгрейд)
+		сам.СценаРежим().РежимУст(cons.РежимАпгрейд)
 		сам.продуктКол.Уст(0)
 		if err := сам.ОбратВремяУст(времОжидБесплат); err != nil {
 			log.Printf("WARN Base.checkArsenalForce(): при установке бесплатного времени ускорения апгрейда арсенала(%v)\n\terr=%v\n", времОжидБесплат, err)
 		}
 	}
 	// Все проверки прошли -- это просто работа
-	сам.РежимТекущ().Уст("work")
+	сам.СценаРежим().РаботаУст("work")
 }
 
 // Проверяет необходимость постройки полигона
@@ -336,7 +337,7 @@ func (сам *Полигон) усилениеПровер() {
 
 // Выбирает самый слабый параметр и усиливает его
 func (сам *Полигон) усилениеДобавить() {
-	if err := сам.сеть.ОбновитьСеть(); err != nil {
+	if ош := сам.сеть.Обновить(); ош != nil {
 		// log._rintf("Polygon.checkPolygon(): при принудительном обновлении lstPlygon, mode=%s\terr=\n\t%v\n", sf.ModeCurrent().Get(), err)
 		сам.ОбратВремяУст("05")
 		return
@@ -419,7 +420,7 @@ func (сам *Полигон) усилениеДобавить() {
 				return
 			}
 			сам.танкСтат.ФорсажОбнов("attack", iForce)
-			сам.РежимТекущ().Уст(стрАтака)
+			сам.СценаРежим().РаботаУст(стрАтака)
 		}
 	case стрБроня: // Усиливаем броню
 		isFind = false
@@ -457,7 +458,7 @@ func (сам *Полигон) усилениеДобавить() {
 				return
 			}
 			сам.танкСтат.ФорсажОбнов(стрБроня, iForce)
-			сам.РежимТекущ().Уст(стрБроня)
+			сам.СценаРежим().РаботаУст(стрБроня)
 		}
 	case стрТочность: // Усиливаем точность
 		isFind = false
@@ -495,7 +496,7 @@ func (сам *Полигон) усилениеДобавить() {
 				return
 			}
 			сам.танкСтат.ФорсажОбнов(стрТочность, iForce)
-			сам.РежимТекущ().Уст(стрТочность)
+			сам.СценаРежим().РаботаУст(стрТочность)
 		}
 	case стрПрочность: // Усиливаем мощность
 		isFind = false
@@ -530,10 +531,10 @@ func (сам *Полигон) усилениеДобавить() {
 				return
 			}
 			сам.танкСтат.ФорсажОбнов(стрПрочность, iForce)
-			сам.РежимТекущ().Уст(стрПрочность)
+			сам.СценаРежим().РаботаУст(стрПрочность)
 		}
 	default: // Неизвестно что
-		сам.РежимТекущ().Уст("неизвестно")
+		сам.СценаРежим().РаботаУст("неизвестно")
 		// log._rintf("ERRO NetPolygon.addForce(): неизвестно что это, strParam=%q", strParam)
 		return
 	}

server/serv_bots/warbot/angar/base/polygon/polygonnet/polygonnet.go

@@ -3,7 +3,7 @@ package polygonnet
 import (
 	"fmt"
 
-	"wartank/pkg/components/section_net"
+	"wartank/pkg/components/scene_net"
 	"wartank/pkg/types"
 )
 
@@ -13,18 +13,18 @@ import (
 
 // ПолигонСеть -- опрашивает полигон на базе
 type ПолигонСеть struct {
-	*section_net.СекцияСеть
+	*scene_net.СценаСеть
 }
 
 // НовПолигонСеть -- возвращает новый *PolygonNet
 func НовПолигонСеть(polygon types.ИБазаПолигон) (*ПолигонСеть, error) {
-	sectionNet, err := section_net.НовСекцияСеть(polygon, "https://wartank.ru/polygon")
+	sectionNet, err := scene_net.НовСекцияСеть(polygon, "https://wartank.ru/polygon")
 	if err != nil {
 		return nil, fmt.Errorf("NewPolygonNet(): in create *SectionNet, err=\n\t%w", err)
 	}
 
 	sf := &ПолигонСеть{
-		СекцияСеть: sectionNet,
+		СценаСеть: sectionNet,
 	}
 
 	return sf, nil

server/serv_bots/warbot/angar/battle/battle.go

@@ -6,7 +6,7 @@ import (
 	"net/http"
 	"time"
 
-	"wartank/pkg/components/section"
+	"wartank/pkg/section"
 	"wartank/pkg/types"
 	"wartank/server/serv_bots/warbot/angar/battle/battle_register"
 	"wartank/server/serv_bots/warbot/angar/battle/battle_wait"

server/serv_bots/warbot/angar/battle/battle_register/battle_register.go

@@ -7,8 +7,8 @@ import (
 	"strings"
 	"time"
 
-	"wartank/pkg/components/section"
-	"wartank/pkg/components/section_net"
+	"wartank/pkg/components/scene_net"
+	"wartank/pkg/section"
 	"wartank/pkg/types"
 )
 
@@ -16,7 +16,7 @@ import (
 type СражениеРегистрация struct {
 	*section.Секция
 	бот          types.ИБот
-	сеть         *section_net.СекцияСеть
+	сеть         *scene_net.СценаСеть
 	счётРегистер int // Счётчик регистраций на сражение
 }
 
@@ -31,7 +31,7 @@ func НовСражениеРегистрация(бот types.ИБот) (*Ср
 		бот:          бот,
 		счётРегистер: 10_000,
 	}
-	сам.сеть, ош = section_net.НовСекцияСеть(сам, "https://wartank.ru/pve")
+	сам.сеть, ош = scene_net.НовСекцияСеть(сам, "https://wartank.ru/pve")
 	if ош != nil {
 		return nil, fmt.Errorf("НовСражениеРегистрация(): in create *SectionNet, err=\n\t%w", ош)
 	}

server/serv_bots/warbot/angar/battle/battle_wait/battle_wait.go

@@ -8,8 +8,8 @@ import (
 	"time"
 
 	"wartank/pkg/alias"
-	"wartank/pkg/components/section"
-	"wartank/pkg/components/section_net"
+	"wartank/pkg/components/scene_net"
+	"wartank/pkg/section"
 	"wartank/pkg/types"
 )
 
@@ -17,7 +17,7 @@ import (
 type СражениеОжидание struct {
 	*section.Секция
 	bot types.ИБот
-	net *section_net.СекцияСеть
+	net *scene_net.СценаСеть
 }
 
 // НовСражениеОжидание -- возвращает новый ожидатель битвы
@@ -31,7 +31,7 @@ func НовСражениеОжидание(bot types.ИБот) (*Сражени
 		Секция: section,
 		bot:    bot,
 	}
-	сам.net, err = section_net.НовСекцияСеть(сам, "https://wartank.ru/pve")
+	сам.net, err = scene_net.НовСекцияСеть(сам, "https://wartank.ru/pve")
 	if err != nil {
 		return nil, fmt.Errorf("NewBattleWait(): in create *SectionNet, err=\n\t%w", err)
 	}
@@ -78,7 +78,7 @@ func (сам *СражениеОжидание) Ожидать() {
 
 // Ждёт пока время не обнулится
 func (сам *СражениеОжидание) ждать() string {
-	if err := сам.net.ОбновитьСеть(); err != nil { // Здесь может уже обратный отсчёт перед сражением
+	if ош := сам.net.Обновить(); ош != nil { // Здесь может уже обратный отсчёт перед сражением
 		return ""
 	}
 	var (

server/serv_bots/warbot/angar/battle/battle_worker/battle_worker.go

@@ -5,8 +5,8 @@ import (
 	"fmt"
 	"time"
 
-	"wartank/pkg/components/section"
-	"wartank/pkg/components/section_net"
+	"wartank/pkg/components/scene_net"
+	"wartank/pkg/section"
 	"wartank/pkg/types"
 	"wartank/server/serv_bots/warbot/angar/battle/battle_worker/battleon"
 	"wartank/server/serv_bots/warbot/angar/battle/battle_worker/battleon/battlesound"
@@ -17,7 +17,7 @@ import (
 type СражениеИсполнитель struct {
 	*section.Секция
 	бот  types.ИБот
-	сеть *section_net.СекцияСеть
+	сеть *scene_net.СценаСеть
 
 	еслиНачало types.ИСтатПарам
 
@@ -43,7 +43,7 @@ func НовСражениеИсполнитель(bot types.ИБот) (*Сраж
 		еслиНачало: еслиНачало,
 		sound:      battlesound.NewBattleSound(),
 	}
-	sf.сеть, err = section_net.НовСекцияСеть(sf, "https://wartank.ru/pve")
+	sf.сеть, err = scene_net.НовСекцияСеть(sf, "https://wartank.ru/pve")
 	if err != nil {
 		return nil, fmt.Errorf("NewBattleWorker(): in create *SectionNet, err=\n\t%w", err)
 	}

server/serv_bots/warbot/angar/battle/battle_worker/battleon/battleon.go

@@ -5,8 +5,8 @@ import (
 	"fmt"
 	"time"
 
-	"wartank/pkg/components/section"
-	"wartank/pkg/components/section_net"
+	"wartank/pkg/components/scene_net"
+	"wartank/pkg/section"
 	"wartank/pkg/types"
 	"wartank/server/serv_bots/warbot/angar/battle/battle_worker/battleon/health"
 	"wartank/server/serv_bots/warbot/angar/battle/battle_worker/battleon/manevr"
@@ -21,7 +21,7 @@ import (
 // СражениеДействие -- непосредственно танкует в сражении
 type СражениеДействие struct {
 	*section.Секция
-	сеть       *section_net.СекцияСеть
+	сеть       types.ИСценаСеть
 	бот        types.ИБот
 	кнт        context.Context // Контекст сражения
 	фнОтменить func()          // Функция отмены сражения
@@ -50,7 +50,7 @@ func НовСражениеДействие(бот types.ИБот) (*Сраже
 		логин:       бот.Имя(),
 		еслиВыстрел: isshot.NewIsShot(),
 	}
-	сам.сеть, ош = section_net.НовСекцияСеть(сам, "https://wartank.ru/pve")
+	сам.сеть, ош = scene_net.НовСекцияСеть(сам, "https://wartank.ru/pve")
 	if ош != nil {
 		return nil, fmt.Errorf("NewBattleOn(): in create *SectionNet, err=\n\t%w", ош)
 	}
@@ -88,7 +88,7 @@ func (сам *СражениеДействие) пуск() {
 }
 
 // Сеть -- возвращает сетевой компонент секции
-func (sf *СражениеДействие) Сеть() types.ИСекцияСеть {
+func (sf *СражениеДействие) Сеть() types.ИСценаСеть {
 	return sf.сеть
 }
 

server/serv_bots/warbot/angar/battle/battle_worker/battleon/shot/shot.go

@@ -73,7 +73,7 @@ func (сам *Выстрел) пуск() {
 //
 //	Вызывается из отдельного потока
 func (сам *Выстрел) выстрел() {
-	if err := сам.Сеть().ОбновитьСеть(); err != nil { // Проверка на непосредственно битву
+	if ош := сам.Сеть().Обновить(); ош != nil { // Проверка на непосредственно битву
 		// <span>закончилась 00:00:07 назад</span>
 		// log._rintf("ERRO Shot.shot(): при обновлении lstBattleOn, err=\n\t%v\n", err)
 		сам.Отменить()

server/serv_bots/warbot/angar/battle/battlenet/battlenet.go

@@ -2,7 +2,7 @@ package battlenet
 
 import (
 	"fmt"
-	"wartank/pkg/components/section_net"
+	"wartank/pkg/components/scene_net"
 	"wartank/pkg/types"
 )
 
@@ -12,17 +12,17 @@ import (
 
 // BattleNet -- танкует в сражении
 type BattleNet struct {
-	*section_net.СекцияСеть
+	*scene_net.СценаСеть
 }
 
 // NewBattleNet -- возвращает новый *BattleNet
 func NewBattleNet(battle types.ИСражениеСцена) (*BattleNet, error) {
-	sectionNet, err := section_net.НовСекцияСеть(battle, "https://wartank.ru/pve")
+	sectionNet, err := scene_net.НовСекцияСеть(battle, "https://wartank.ru/pve")
 	if err != nil {
 		return nil, fmt.Errorf("NewBattleNet(): in create *SectionNet, err=\n\t%w", err)
 	}
 	sf := &BattleNet{
-		СекцияСеть: sectionNet,
+		СценаСеть: sectionNet,
 	}
 	return sf, nil
 }

server/serv_bots/warbot/angar/convoy/convoy.go

@@ -10,7 +10,7 @@ import (
 	"github.com/sirupsen/logrus"
 
 	"wartank/pkg/alias"
-	"wartank/pkg/components/section"
+	"wartank/pkg/section"
 	"wartank/pkg/types"
 	"wartank/server/serv_bots/warbot/angar/convoy/convoynet"
 	"wartank/server/serv_bots/warbot/tank/tankstat/static_param"
@@ -58,7 +58,7 @@ func (sf *Конвой) Пуск() error {
 
 // UpdateLst -- принудительно обновляет состояние конвоя
 func (sf *Конвой) UpdateLst() {
-	if err := sf.net.ОбновитьСеть(); err != nil {
+	if err := sf.net.Обновить(); err != nil {
 		log.Printf("Конвой.UpdateLst(): err=\n\t%v\n", err)
 	}
 }
@@ -138,7 +138,7 @@ func (sf *Конвой) Обновить() {
 // Обновляет оставшееся время конвоя
 func (sf *Конвой) обновитьВремя() {
 	// Время подходит надо обновляться
-	if err := sf.net.ОбновитьСеть(); err != nil {
+	if err := sf.net.Обновить(); err != nil {
 		logrus.WithError(err).Error("Конвой.обновитьВремя(): при выполнении GET-команды обновления")
 		sf.ОбратВремяУст("20")
 		return
@@ -335,7 +335,7 @@ func (sf *Конвой) проверитьМиссияРазведкаКонво
 		strOut string
 		isFind bool
 	)
-	if err := sf.net.ОбновитьСеть(); err != nil {
+	if err := sf.net.Обновить(); err != nil {
 		// log._rintf("Конвой.проверитьМиссияРазведкаКонвой(): при обновлении пустого lstConvoy, err=\n\t%v\n", err)
 		return
 	}
@@ -376,7 +376,7 @@ func (sf *Конвой) проверитьМиссияМастерРазведк
 		ind       int
 	)
 	if len(lstConvoy) == 0 {
-		if err := sf.net.ОбновитьСеть(); err != nil {
+		if err := sf.net.Обновить(); err != nil {
 			// log._rintf("Конвой.проверитьМиссияМастерРазведки(): при обновлении пустого lstConvoy, err=\n\t%v\n", err)
 			return
 		}
@@ -420,7 +420,7 @@ func (sf *Конвой) проверитьМиссия6фрагов() {
 		strOut string
 		isFind bool
 	)
-	if err := sf.net.ОбновитьСеть(); err != nil {
+	if err := sf.net.Обновить(); err != nil {
 		// log._rintf("Конвой.check6frage(): при обновлении пустого lstConvoy, err=\n\t%v\n", err)
 		return
 	}

server/serv_bots/warbot/angar/convoy/convoynet/convoynet.go

@@ -2,7 +2,7 @@ package convoynet
 
 import (
 	"fmt"
-	"wartank/pkg/components/section_net"
+	"wartank/pkg/components/scene_net"
 	"wartank/pkg/types"
 )
 
@@ -12,17 +12,17 @@ import (
 
 // ConvoyNet -- танкует с конвоем в сети
 type ConvoyNet struct {
-	*section_net.СекцияСеть
+	*scene_net.СценаСеть
 }
 
 // NewConvoyNet -- возвращает новый *ConvoyNet
 func NewConvoyNet(convoy types.Конвой) (*ConvoyNet, error) {
-	sectionNet, err := section_net.НовСекцияСеть(convoy, "https://wartank.ru/convoy")
+	sectionNet, err := scene_net.НовСекцияСеть(convoy, "https://wartank.ru/convoy")
 	if err != nil {
 		return nil, fmt.Errorf("NewConvoyNet(): in create *SectionNet, err=\n\t%w", err)
 	}
 	sf := &ConvoyNet{
-		СекцияСеть: sectionNet,
+		СценаСеть: sectionNet,
 	}
 	return sf, nil
 }

server/serv_bots/warbot/angar/division/divwar/divwar.go

@@ -9,7 +9,7 @@ import (
 	"time"
 
 	"wartank/pkg/alias"
-	"wartank/pkg/components/section"
+	"wartank/pkg/section"
 	"wartank/pkg/types"
 	"wartank/server/serv_bots/warbot/angar/division/divwar/divwarnet"
 	"wartank/server/serv_bots/warbot/angar/division/divwar/divwaron"
@@ -121,7 +121,7 @@ func (sf *DivWar) run() {
 
 // Ищет время до начала битвы дивизий
 func (sf *DivWar) findTimeCount() {
-	if err := sf.net.ОбновитьСеть(); err != nil { // Здесь может уже обратный отсчёт перед сражением
+	if err := sf.net.Обновить(); err != nil { // Здесь может уже обратный отсчёт перед сражением
 		sf.chDivWar <- 1
 		return
 	}

server/serv_bots/warbot/angar/division/divwar/divwarnet/divwarnet.go

@@ -3,7 +3,7 @@ package divwarnet
 import (
 	"fmt"
 
-	"wartank/pkg/components/section_net"
+	"wartank/pkg/components/scene_net"
 	"wartank/pkg/types"
 )
 
@@ -13,7 +13,7 @@ import (
 
 // DivWarNet -- танкует в сражении
 type DivWarNet struct {
-	*section_net.СекцияСеть
+	*scene_net.СценаСеть
 	bot types.ИБот
 }
 

server/serv_bots/warbot/angar/division/divwar/divwaron/divwaron.go

@@ -7,8 +7,8 @@ import (
 	"time"
 
 	"wartank/pkg/components/safe_bool"
-	"wartank/pkg/components/section"
-	"wartank/pkg/components/section_net"
+	"wartank/pkg/components/scene_net"
+	"wartank/pkg/section"
 	"wartank/pkg/types"
 	"wartank/server/serv_bots/warbot/angar/division/divwar/divwaron/health"
 	"wartank/server/serv_bots/warbot/angar/division/divwar/divwaron/manevr"
@@ -23,7 +23,7 @@ import (
 type DivWarOn struct {
 	*section.Секция
 	bot            types.ИБот
-	net            *section_net.СекцияСеть
+	сеть           types.ИСценаСеть
 	ctxDivWar      context.Context // Контекст сражения
 	fnCancelDivWar func()          // Функция отмены сражения
 
@@ -57,7 +57,10 @@ func NewDivWarOn(bot types.ИБот) (*DivWarOn, error) {
 			return nil, fmt.Errorf("NewDivWarOn(): in create *Section, err=\n\t%w", err)
 		}
 	}
-	// sf.net = sectionnet.NewSectionNet(server, bot, "https://wartank.ru/pve")
+	sf.сеть, err = scene_net.НовСекцияСеть(sf, "https://wartank.ru/pve")
+	if err != nil {
+		return nil, fmt.Errorf("NewDivWarOn(): in create ИСценаСеть, err=\n\t%w", err)
+	}
 	if sf.checkEnd() {
 		return nil, fmt.Errorf("NewDivWarOn(): нет страницы для сражения")
 	}
@@ -124,8 +127,8 @@ func (sf *DivWarOn) run() {
 }
 
 // Сеть -- возвращает сетевой компонент секции
-func (sf *DivWarOn) Сеть() types.ИСекцияСеть {
-	return sf.net
+func (sf *DivWarOn) Сеть() types.ИСценаСеть {
+	return sf.сеть
 }
 
 // Проверяет окончание сражения
@@ -137,7 +140,7 @@ func (sf *DivWarOn) checkEnd() bool {
 		}
 	}()
 
-	if err := sf.net.ОбновитьСеть(); err != nil {
+	if err := sf.сеть.Обновить(); err != nil {
 		// log._rintf("WARN DivWarOn.checkEnd(): при обновлении lstDivWarOn, err=\n\t%v\n", err)
 		sf.isEnd.Уст()
 		sf.fnCancelDivWar()

server/serv_bots/warbot/angar/division/divwar/divwaron/health/health.go

@@ -250,7 +250,7 @@ func (sf *Health) findHealth() error {
 		lstBattle = sf.СписПолучить()
 	)
 	if len(lstBattle) == 0 { // Принудительно обновим сражение
-		if err := sf.Сеть().ОбновитьСеть(); err != nil {
+		if err := sf.Сеть().Обновить(); err != nil {
 			sf.isEnd.Уст()
 			sf.fnCancel()
 			return fmt.Errorf("Health.findHealth(): после принудительного обновления lsBattleOn, err=\n\t%w", err)

server/serv_bots/warbot/angar/division/divwar/divwaron/shot/shot.go

@@ -122,7 +122,7 @@ func (sf *Shot) run() {
 //
 //	Вызывается из отдельного потока
 func (sf *Shot) shot() {
-	if err := sf.Сеть().ОбновитьСеть(); err != nil { // Проверка на непосредственно битву
+	if err := sf.Сеть().Обновить(); err != nil { // Проверка на непосредственно битву
 		// <span>закончилась 00:00:07 назад</span>
 		// log._rintf("ERRO Shot.shot(): при обновлении lstBattleOn, err=\n\t%v\n", err)
 		sf.isEnd.Уст()

server/serv_bots/warbot/angar/fuel_attack/fuel_attack.go

@@ -8,26 +8,26 @@ import (
 	"strings"
 	"time"
 
-	"wartank/pkg/components/section_net"
+	"wartank/pkg/components/scene_net"
 	"wartank/pkg/cons"
 	"wartank/pkg/types"
 )
 
 // ТопливоБой -- объект боя на топливе
 type ТопливоБой struct {
-	*section_net.СекцияСеть
+	*scene_net.СценаСеть
 	ангар types.ИАнгар
 }
 
 // НовТопливоБой -- возвращает новый *ТопливоБойNet
 func НовТопливоБой(angar types.ИАнгар) (*ТопливоБой, error) {
-	sectionNet, err := section_net.НовСекцияСеть(angar, "https://wartank.ru/battle")
+	sectionNet, err := scene_net.НовСекцияСеть(angar, "https://wartank.ru/battle")
 	if err != nil {
 		return nil, fmt.Errorf("NewТопливоБой(): in create SectionNet, err=\n\t%w", err)
 	}
 	sf := &ТопливоБой{
-		СекцияСеть: sectionNet,
-		ангар:      angar,
+		СценаСеть: sectionNet,
+		ангар:     angar,
 	}
 	return sf, nil
 }

server/serv_bots/warbot/angar/masters/bat_masters.go

@@ -7,7 +7,7 @@ import (
 	"time"
 
 	"wartank/pkg/alias"
-	"wartank/pkg/components/section"
+	"wartank/pkg/section"
 	"wartank/pkg/types"
 	"wartank/server/serv_bots/warbot/angar/masters/batmasnet"
 )
@@ -86,7 +86,7 @@ func (sf *БитваМастеров) goBatMas() bool {
 	}
 
 	// Время меньше 25 сек, надо уточнять (тут возможна ошибка с экраном ожидания)
-	if err := sf.сеть.ОбновитьСеть(); err != nil {
+	if err := sf.сеть.Обновить(); err != nil {
 		// log._rintf("ERRO Battle.goBattle().fnCountDown(): при обновлении lstBattle, err=\n\t%v\n", err)
 		// Возможно времени уже не осталось
 		return true
@@ -128,7 +128,7 @@ func (sf *БитваМастеров) findTimeCount() {
 //
 //	вызывается только если есть награда
 func (sf *БитваМастеров) upBattle() bool {
-	if err := sf.сеть.ОбновитьСеть(); err != nil {
+	if err := sf.сеть.Обновить(); err != nil {
 		// log._rintf("ERRO BatMas.upBattle(): при обновлении lstBattle, err=\n\t%v\n", err)
 		return false
 	}

server/serv_bots/warbot/angar/masters/batmasnet/batmasnet.go

@@ -3,7 +3,7 @@ package batmasnet
 import (
 	"fmt"
 
-	"wartank/pkg/components/section_net"
+	"wartank/pkg/components/scene_net"
 	"wartank/pkg/types"
 )
 
@@ -13,7 +13,7 @@ import (
 
 // BatMasNet -- танкует в битве мастеров
 type BatMasNet struct {
-	*section_net.СекцияСеть
+	*scene_net.СценаСеть
 	bot types.ИБот
 }
 

server/serv_bots/warbot/angar/missions/missions.go

@@ -6,7 +6,7 @@ import (
 	"strings"
 	"time"
 
-	"wartank/pkg/components/section"
+	"wartank/pkg/section"
 	"wartank/pkg/types"
 	"wartank/server/serv_bots/warbot/angar/missions/missionsnet"
 )
@@ -119,7 +119,7 @@ func (сам *Миссии) сражениеЗащита() {
 		strOut string
 		isFind bool
 	)
-	ош := сам.сеть.ОбновитьСеть()
+	ош := сам.сеть.Обновить()
 	if ош != nil {
 		log.Printf("Миссии.сражениеЗащита(): при обновлении списка строк миссий, ош:=\n\t%v\n", ош)
 		return
@@ -197,7 +197,7 @@ func (сам *Миссии) сражениеНаступление() {
 		lstMissions = сам.СписПолучить()
 	)
 	if len(lstMissions) == 0 {
-		if ош := сам.сеть.ОбновитьСеть(); ош != nil {
+		if ош := сам.сеть.Обновить(); ош != nil {
 			log.Printf("Миссии.сражениеНаступление(): при обновлении HTML миссий, ош=\n\t%v\n", ош)
 			return
 		}

server/serv_bots/warbot/angar/missions/missionsnet/missionsnet.go

@@ -3,7 +3,7 @@ package missionsnet
 import (
 	"fmt"
 
-	"wartank/pkg/components/section_net"
+	"wartank/pkg/components/scene_net"
 	"wartank/pkg/types"
 )
 
@@ -13,18 +13,18 @@ import (
 
 // MissionsNet -- автоматически собирает золото
 type MissionsNet struct {
-	*section_net.СекцияСеть
+	*scene_net.СценаСеть
 }
 
 // NewMissionsNet -- возвращает новый *MissionsNet
 func NewMissionsNet(mission types.ИМиссии) (*MissionsNet, error) {
-	sectionNet, err := section_net.НовСекцияСеть(mission, "https://wartank.ru/missions/")
+	sectionNet, err := scene_net.НовСекцияСеть(mission, "https://wartank.ru/missions/")
 	if err != nil {
 		return nil, fmt.Errorf("NewMissionsNet(): in create *SectionNet, err=\n\t%w", err)
 	}
 
 	sf := &MissionsNet{
-		СекцияСеть: sectionNet,
+		СценаСеть: sectionNet,
 	}
 	return sf, nil
 }

server/serv_bots/warbot/warbot_net/warbot_net.go

@@ -7,7 +7,7 @@ import (
 	"net/http"
 
 	"wartank/pkg/components/safe_bool"
-	"wartank/pkg/components/section_net/netclient"
+	"wartank/pkg/components/scene_net/netclient"
 	"wartank/pkg/types"
 	"wartank/server/serv_bots/warbot/warbot_net/bot_net_conn"
 	"wartank/server/serv_bots/warbot/warbot_net/bot_net_login"

server/serv_web/serv_web.go

@@ -177,13 +177,13 @@ func (сам *СервВеб) постБотСтат(кнт *fiber.Ctx) error {
 	диктБот["мощь"] = fmt.Sprintf("%v", бот.Танк().ТанкСтат().Мощь().Получ())
 
 	диктБот["шахта_уровень"] = fmt.Sprintf("%v", бот.Ангар().База().Шахта().Уровень().Получ())
-	диктБот["шахта_режим"] = fmt.Sprintf("%v", бот.Ангар().База().Шахта().РежимТекущ().Получ())
+	диктБот["шахта_режим"] = fmt.Sprintf("%v", бот.Ангар().База().Шахта().СценаРежим().Режим())
 	диктБот["шахта_сделать_кол"] = fmt.Sprintf("%v", бот.Ангар().База().Шахта().ПродуктКолСейчас())
 	диктБот["шахта_сделать_назв"] = бот.Ангар().База().Шахта().ПродуктИмяСейчас()
 	диктБот["шахта_сделать_время"] = бот.Ангар().База().Шахта().ПродуктВремяСейчас()
 
 	диктБот["полигон_уровень"] = fmt.Sprintf("%v", бот.Ангар().База().Полигон().Уровень().Получ())
-	диктБот["полигон_режим"] = fmt.Sprintf("%v", бот.Ангар().База().Полигон().РежимТекущ().Получ())
+	диктБот["полигон_режим"] = fmt.Sprintf("%v", бот.Ангар().База().Полигон().СценаРежим().Режим())
 	диктБот["полигон_сделать_кол"] = fmt.Sprintf("%v", бот.Ангар().База().Полигон().ПродуктКолСейчас())
 	диктБот["полигон_сделать_назв"] = бот.Ангар().База().Полигон().ПродуктИмяСейчас()
 	диктБот["полигон_сделать_время"] = бот.Ангар().База().Полигон().ПродуктВремяСейчас()