d08 Внедрение интерфейсов

Makefile

@@ -32,6 +32,13 @@ dev.run:
 	# go build -race -o ./bin_dev/wartank_dev ./cmd/server/main.go
 	go build -ldflags "-w -s -X main.GoVersion=$(GO_VERS) -X main.Version=${TAG} -X main.Date=${BUILD_DATE}" -o ./bin_dev/wartank_dev ./cmd/server/main.go
 	./run_dev.sh
+debug.run:
+	clear
+	cp -r ./web ./bin_dev
+	go fmt ./...
+	# go build -race -o ./bin_dev/wartank_dev ./cmd/server/main.go
+	go build -ldflags "-w -s -X main.GoVersion=$(GO_VERS) -X main.Version=${TAG} -X main.Date=${BUILD_DATE}" -o ./bin_dev/wartank_dev ./cmd/server/main.go
+	./debug.sh
 prod.run:
 	clear
 	go fmt ./...

README.md

@@ -12,17 +12,25 @@
 
 Бот работает с RPC-мордой. После запуска сервера надо запустить десктоп клиент:
 
-- при работе: [localhost:18050](http://localhost:18050/)
-- при разработке: [localhost:18050](http://localhost:18060/)
+* при работе: [localhost:18050](http://localhost:18050/)
+* при разработке: [localhost:18050](http://localhost:18060/)
+
+## Бот для разработки
+
+```text
+Ну допустим
+qwe123
+```
 
 ## Цели сборки
 
 ```bash
-make          # Сборка бота
-make build    # -//-
-make dev.run  # Сборка и запуск бота в разработке
-make prod.run # Сборка и запуск бота в проде
-make mod      # Обновление зависимостей
-make test.run # Запуск всех тестов
-make lint     # Запуск всех линтеров
+make           # Сборка бота
+make build     # -//-
+make dev.run   # Сборка и запуск бота в разработке
+make prod.run  # Сборка и запуск бота в проде
+make debug.run # Сборка и запуск бота без удаления учётных данных
+make mod       # Обновление зависимостей
+make test.run  # Запуск всех тестов
+make lint      # Запуск всех линтеров
 ```

cmd/desc_lorca/main.go

@@ -6,16 +6,16 @@
 package main
 
 import (
-	"log"
 	"net/http"
 	_ "net/http/pprof"
 	"os"
 	"time"
-
 	"wartank/desc_lorca"
+	"wartank/pkg/components/kernel/logger"
 )
 
 func профилировать() {
+	лог := logger.НовЛоггер("Профиль")
 	порт := "29081"
 	стенд := os.Getenv("STAGE")
 	if стенд == "prod" {
@@ -24,7 +24,7 @@ func профилировать() {
 	for {
 		ош := http.ListenAndServe("0.0.0.0:"+порт, nil)
 		if ош != nil {
-			log.Printf("профилировать(): при запуске pprof, err=\n\t%v\n", ош)
+			лог.Ошибка("Профиль(): ошибка при запуске профилировщика, ош=\n\t%v\n", ош)
 		}
 		time.Sleep(time.Second * 1)
 	}
@@ -40,19 +40,13 @@ var (
 )
 
 func main() {
-	log.Printf("server/main():\n\tgo = %v\n\tvers = %v\n\tdate = %v\n", GoVersion, Version, Date)
+	лог := logger.НовЛоггер("main")
+	лог.Инфо("server:\n\tgo = %v\n\tvers = %v\n\tdate = %v\n", GoVersion, Version, Date)
 	go профилировать()
-	десктоп, ош := desc_lorca.НовДесктопЛорка()
-	if ош != nil {
-		log.Printf("main(): при создании ДесктопЛорка, ош=\n\t%v\n", ош)
-		os.Exit(1)
-	}
+	десктоп := desc_lorca.НовДесктопЛорка()
 	go func() {
 		time.Sleep(time.Minute * 20)
 		десктоп.Отменить()
 	}()
-	if ош = десктоп.Пуск(); ош != nil {
-		log.Printf("main(): при работе десктопа, ош=\n\t%v\n", ош)
-		os.Exit(2)
-	}
+	десктоп.Пуск()
 }

cmd/server/main.go

@@ -9,15 +9,16 @@
 package main
 
 import (
-	"log"
 	"net/http"
 	_ "net/http/pprof"
 	"os"
 	"time"
+	"wartank/pkg/components/kernel/logger"
 	"wartank/server"
 )
 
 func profile() {
+	лог := logger.НовЛоггер("Профиль")
 	port := "29081"
 	stage := os.Getenv("STAGE")
 	if stage == "prod" {
@@ -26,7 +27,7 @@ func profile() {
 	for {
 		err := http.ListenAndServe("0.0.0.0:"+port, nil)
 		if err != nil {
-			log.Printf("profile(): in run pprof, err=\n\t%v\n", err)
+			лог.Ошибка("profile(): ошибка при запуске профилировщика, err=\n\t%v\n", err)
 		}
 		time.Sleep(time.Second * 1)
 	}
@@ -42,19 +43,14 @@ var (
 )
 
 func main() {
-	log.Printf("server/main():\n\tgo = %v\n\tvers = %v\n\tdate = %v\n", GoVersion, Version, Date)
+	лог := logger.НовЛоггер("main")
+	лог.Инфо("main():\n\tgo = %v\n\tvers = %v\n\tdate = %v\n", GoVersion, Version, Date)
 	go profile()
-	serv, err := server.НовСервер()
-	if err != nil {
-		log.Printf("main(): in make IServer, err=\n\t%v\n", err)
-		os.Exit(1)
-	}
+	сервер := server.НовСервер()
 	go func() {
 		time.Sleep(time.Minute * 20)
-		serv.Отменить()
+		сервер.Отменить()
 	}()
-	if err := serv.Пуск(); err != nil {
-		log.Printf("main(): in run server, err=\n\t%v\n", err)
-		os.Exit(2)
-	}
+	ош := сервер.Пуск()
+	лог.Проверить(ош == nil, "Сервер.Пуск(): ошибка при запуске сервера, ош=\n\t%v\n", ош)
 }

debug.sh

@@ -0,0 +1,4 @@
+export STAGE="local"
+
+cd ./bin_dev
+./wartank_dev

desc_lorca/desc_lorca.go

@@ -2,9 +2,8 @@
 package desc_lorca
 
 import (
-	"fmt"
-	"log"
 	"wartank/desc_lorca/lorca_gui"
+	"wartank/pkg/components/kernel/logger"
 	"wartank/server"
 )
 
@@ -12,22 +11,21 @@ import (
 type ДесктопЛорка struct {
 	сервер   *server.Сервер      // Сервер для взаимодействия с лоркой
 	гипЛорка *lorca_gui.ЛоркаГуи // ГИП десктопа на Лорке
+	лог      *logger.Логгер
 }
 
 // НовДесктопЛорка -- возвращает новый десктоп на Лорке
-func НовДесктопЛорка() (*ДесктопЛорка, error) {
+func НовДесктопЛорка() *ДесктопЛорка {
+	лог := logger.НовЛоггер("ДесктопЛорка")
+	лог.Инфо("НовДесктопЛорка()\n")
 	гип, ош := lorca_gui.НовЛоркаГуи()
-	if ош != nil {
-		return nil, fmt.Errorf("НовДесктопЛорка(): при создании ЛоркаГуи, ош=\n\t%w", ош)
-	}
+	лог.Проверить(ош == nil, "НовДесктопЛорка(): при создании ЛоркаГуи, ош=\n\t%v\n", ош)
 	сам := &ДесктопЛорка{
 		гипЛорка: гип,
+		лог:      лог,
 	}
-	сам.сервер, ош = server.НовСервер()
-	if ош != nil {
-		return nil, fmt.Errorf("НовДесктопЛорка(): при создании ИСервер, ош=\n\t%w", ош)
-	}
-	return сам, nil
+	сам.сервер = server.НовСервер()
+	return сам
 }
 
 // Отменить -- отменяет работу десктопа
@@ -36,13 +34,10 @@ func (сам *ДесктопЛорка) Отменить() {
 }
 
 // Пуск -- запускает работу десктопа
-func (сам *ДесктопЛорка) Пуск() error {
+func (сам *ДесктопЛорка) Пуск() {
 	go func() {
 		ош := сам.сервер.Пуск()
-		if ош != nil {
-			log.Printf("ДесктопЛорка.Пуск(): ош=\n\t%v\n", ош)
-		}
+		сам.лог.Проверить(ош == nil, "Пуск(): при запуске сервера, ош=\n\t%v\n", ош)
 	}()
 	сам.сервер.Wg().Wait()
-	return nil
 }

pkg/alias/alias.go

@@ -22,14 +22,17 @@ type Мин uint
 // Сек -- количество секунд
 type Сек uint
 
-// СценаИмя -- имя сцены
-type СценаИмя string
+// АренаИмя -- имя арены
+type АренаИмя string
 
-// СценаРежим -- режим сцены (не существует, апгрейд, ожидание, работа)
-type СценаРежим string
+// АренаСостояние -- состояние арены (не существует, апгрейд, ожидание, работа)
+type АренаСостояние string
 
-// СценаРабота -- работа сцены (серебро-1. серебро-3, ремка-4 и т.п.)
-type СценаРабота string
+// АренаРаботаИмя -- имя текущей работы арены (серебро-1, серебро-3, зависит от выбранного режима)
+type АренаРаботаИмя string
+
+// АренаРежимНомер -- номер режима прены (1/2)
+type АренаРежимНомер int
 
 // БотНомер -- номер бота
 type БотНомер int

pkg/arena/arena.go

@@ -0,0 +1,63 @@
+// package arena -- типовая арена работы части игры (банк, арсенал и т.п.)
+package arena
+
+import (
+	"fmt"
+	"log"
+	"sync"
+	"wartank/pkg/alias"
+	"wartank/pkg/arena/arena_context"
+	"wartank/pkg/arena/arena_string"
+	"wartank/pkg/arena/down_time"
+	"wartank/pkg/types"
+)
+
+// Арена -- арена игры
+type Арена struct {
+	types.ИАренаКонтекст
+	времяОстат types.ИВремяОстат         // Обратный отсчёт до окончания работы режима
+	списСтр    *arena_string.АренаСтроки // Список строк из сети для анализа секции
+	блок       sync.RWMutex
+}
+
+// НовАрена -- возвращает новую арену игры
+func НовАрена(бот types.ИБот, сценаИмя alias.АренаИмя, стрКонтроль string) *Арена {
+	log.Printf("НовАрена(): стрКонтроль=%q\n", стрКонтроль)
+	аренаКонтекст := arena_context.НовАренаКонтекст(бот, сценаИмя)
+	сам := &Арена{
+		ИАренаКонтекст: аренаКонтекст,
+		времяОстат:     down_time.НовВремОбрат(аренаКонтекст, 5),
+		списСтр:        arena_string.НовАренаСтроки(стрКонтроль),
+	}
+	_ = types.ИАрена(сам)
+	return сам
+}
+
+// СтрОбновить -- обновляет список строк секции по требованию
+func (сам *Арена) СтрОбновить(lstString []string) error {
+	if err := сам.списСтр.Set(lstString); err != nil {
+		return fmt.Errorf("Арена.СтрОбновить(): при установке lstString, err=\n\t%w", err)
+	}
+	return nil
+}
+
+// СписПолучить -- возвращает список строк секции
+func (сам *Арена) СписПолучить() []string {
+	return сам.списСтр.Get()
+}
+
+// ОбратВремяУст -- устанавливает новое значение обратного счётчика времени
+func (сам *Арена) ОбратВремяУст(времяСек alias.Время) error {
+	ош := сам.времяОстат.Уст(времяСек)
+	if ош != nil {
+		return fmt.Errorf("Арена.ОбратВремяУст(): ош=\n\t%w", ош)
+	}
+	return nil
+}
+
+// ВремяОстат -- объект оставшегося времени
+func (сам *Арена) ВремяОстат() types.ИВремяОстат {
+	сам.блок.RLock()
+	defer сам.блок.RUnlock()
+	return сам.времяОстат
+}

pkg/arena/arena_context/arena_context.go

@@ -0,0 +1,72 @@
+// package arena_context -- контекст арены
+package arena_context
+
+import (
+	"context"
+	"wartank/pkg/alias"
+	"wartank/pkg/arena/arena_context/arena_state"
+	"wartank/pkg/components/kernel/logger"
+	"wartank/pkg/components/web_log"
+	"wartank/pkg/types"
+)
+
+// АренаКонтекст -- контекст арены
+type АренаКонтекст struct {
+	бот       types.ИБот
+	аренаИмя  alias.АренаИмя
+	кнт       context.Context
+	фнОтмена  func()
+	состояние types.ИАренаСостояние
+	вЛог      types.ИВебЛог
+	лог       types.ИЛоггер
+}
+
+// НовАренаКонтекст -- возвращает новый контекст арены
+func НовАренаКонтекст(бот types.ИБот, сценаИмя alias.АренаИмя) *АренаКонтекст {
+	лог := logger.НовЛоггер("АренаКонтекст " + string(сценаИмя))
+	лог.Инфо("НовАренаКонтекст() " + string(сценаИмя) + "\n")
+	лог.Проверить(бот != nil, "НовАренаКонтекст(): ИБот==nil")
+	лог.Проверить(сценаИмя != "", "НовАренаКонтекст(): сценаИмя не задано")
+	кнт, фнОтмена := context.WithCancel(бот.Контекст())
+	сам := &АренаКонтекст{
+		бот:       бот,
+		аренаИмя:  сценаИмя,
+		кнт:       кнт,
+		фнОтмена:  фнОтмена,
+		состояние: arena_state.НовАренаСостояние(),
+		вЛог:      web_log.НовВебЛог(true),
+		лог:       лог,
+	}
+	_ = types.ИАренаКонтекст(сам)
+	return сам
+}
+
+// Лог -- возвращает лог арены
+func (сам *АренаКонтекст) ВебЛог() types.ИВебЛог {
+	return сам.вЛог
+}
+
+// АренаСостояние -- состояние арены
+func (сам *АренаКонтекст) АренаСостояние() types.ИАренаСостояние {
+	return сам.состояние
+}
+
+// Отмена -- отменяет контекст арены
+func (сам *АренаКонтекст) Отмена() {
+	сам.фнОтмена()
+}
+
+// Кнт -- возвращает контекст арены
+func (сам *АренаКонтекст) Контекст() context.Context {
+	return сам.кнт
+}
+
+// Имя -- возвращает имя арены
+func (сам *АренаКонтекст) Имя() alias.АренаИмя {
+	return сам.аренаИмя
+}
+
+// Бот -- возвращает бота сцены
+func (сам *АренаКонтекст) Бот() types.ИБот {
+	return сам.бот
+}

pkg/arena/arena_context/arena_state/arena_state.go

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

pkg/arena/arena_string/arena_string.go

@@ -0,0 +1,63 @@
+// package arena_string -- потокобезопасный компонент списка строк для анализа арены
+package arena_string
+
+import (
+	"fmt"
+	"strings"
+	"sync"
+	"wartank/pkg/components/kernel/logger"
+)
+
+// АренаСтроки -- потокобезопасный список строк арены
+type АренаСтроки struct {
+	val        []string
+	strControl string // Контрольная строка в исходной строке для анализа арены
+	block      sync.RWMutex
+}
+
+// НовАренаСтроки -- возвращает новый потокобезопасный список строк арены
+func НовАренаСтроки(strControl string) *АренаСтроки {
+	лог := logger.НовЛоггер("АренаСтроки")
+	лог.Отладка("НовАренаСтроки(): strControl=%q", strControl)
+	лог.Проверить(strControl != "", "НовАренаСтроки(): strControl is empty")
+	сам := &АренаСтроки{
+		val:        make([]string, 0),
+		strControl: strControl,
+	}
+	return сам
+}
+
+// Get -- возвращает список строк для анализа
+func (сам *АренаСтроки) Get() []string {
+	сам.block.RLock()
+	defer сам.block.RUnlock()
+	return сам.val
+}
+
+// Set -- устанавливает список строк для анализа
+func (сам *АренаСтроки) Set(lstString []string) error {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	if lstString == nil {
+		return fmt.Errorf("АренаСтроки.Set(): lstString is nil")
+	}
+	isOk := false
+	for _, strControl := range lstString {
+		if strings.Contains(strControl, сам.strControl) {
+			isOk = true
+			break
+		}
+	}
+	if isOk {
+		сам.val = lstString
+		return nil
+	}
+	// Найти заголовок
+	var strOut string
+	for _, strOut = range lstString {
+		if strings.Contains(strOut, "<title>") {
+			break
+		}
+	}
+	return fmt.Errorf("АренаСтроки.Set(): lstString не имеет правильный title(%q), фактически(%q)", сам.strControl, strOut)
+}

pkg/section/down_time/down_time.go → pkg/arena/down_time/down_time.go

@@ -8,9 +8,8 @@ import (
 	// "log"
 	"sync"
 	"time"
-
 	"wartank/pkg/alias"
-	"wartank/pkg/components/parser_time"
+	"wartank/pkg/components/product/parser_time"
 	"wartank/pkg/components/safe_bool"
 	"wartank/pkg/components/safe_int"
 	"wartank/pkg/types"
@@ -22,7 +21,7 @@ const (
 
 // ВремОбрат -- счётчик обратного времени для игровой зоны (анга, база, битва и т.п.)
 type ВремОбрат struct {
-	сцена types.ИСцена // Сцена, которой принадлежит отсчёт времени
+	сцена types.ИАренаКонтекст // Сцена, которой принадлежит отсчёт времени
 
 	остатПарсер types.ИПарсерВремя // Парсер значения (мсек)
 
@@ -39,7 +38,7 @@ type ВремОбрат struct {
 }
 
 // НовВремОбрат -- возвращает новый *CountTime
-func НовВремОбрат(сцена types.ИСцена, время alias.МилСек) *ВремОбрат {
+func НовВремОбрат(сцена types.ИАренаКонтекст, время alias.МилСек) *ВремОбрат {
 	if сцена == nil {
 		panic("НовВремОбрат(): ИСцена == nil")
 	}

pkg/section/down_time/down_time_test.go → pkg/arena/down_time/down_time_test.go

@@ -5,6 +5,7 @@ import (
 	"time"
 	"wartank/pkg/alias"
 	"wartank/pkg/components/safe_bool"
+
 	// "wartank/pkg/mock/mock_zone"
 	"wartank/pkg/mock/mockapp"
 	"wartank/pkg/types"
@@ -18,7 +19,7 @@ import (
 type tester struct {
 	t      *testing.T
 	app    *mockapp.MockApp
-	zone   types.ИСцена
+	zone   types.ИАренаКонтекст
 	ct     *ВремОбрат
 	err    error
 	isCall *safe_bool.БезопБул // Признак обратного вызова

pkg/bot/bot.go

@@ -1,8 +0,0 @@
-// package bot -- объект бота
-package bot
-
-// Bot -- объект бота
-type Bot struct {
-	Login_ string
-	Pass_  string
-}

pkg/components/arena_net/arena_net.go

@@ -0,0 +1,66 @@
+// package arena_net -- сетевая арена
+package arena_net
+
+import (
+	"fmt"
+	"strings"
+	"sync"
+	"wartank/pkg/components/kernel/logger"
+	"wartank/pkg/types"
+)
+
+// АренаСеть -- базовый тип для сетевых арен
+type АренаСеть struct {
+	types.ИБотСеть
+	клиент types.ИВебВоркер
+	сцена  types.ИСценаСтр
+	стрУрл string
+	блок   sync.Mutex
+	лог    types.ИЛоггер
+}
+
+// НовСценаСеть -- возвращает новый *АренаСеть
+func НовАренаСеть(сцена types.ИСценаСтр, стрУрл string) *АренаСеть {
+	лог := logger.НовЛоггер("АренаСеть")
+	лог.Инфо("НовАренаСеть(): strUrl=%q\n", стрУрл)
+	лог.Проверить(сцена != nil, "НовАренаСеть(): ИСценаСтр == nil")
+	лог.Проверить(стрУрл != "", "НовАренаСеть(): стрУрл пустой\n")
+	сам := &АренаСеть{
+		ИБотСеть: сцена.Бот().Сеть(),
+		сцена:    сцена,
+		стрУрл:   стрУрл,
+		клиент:   сцена.Бот().Сеть().ВебВоркер(),
+		лог:      лог,
+	}
+	_ = types.ИАренаСеть(сам)
+	return сам
+}
+
+// Обновить -- обновляет список строк
+func (сам *АренаСеть) Обновить() {
+	сам.блок.Lock()
+	defer сам.блок.Unlock()
+	// FIXME: попытка разобраться, что за фигня творится
+	// time.Sleep(time.Millisecond * 500)
+	сам.лог.Отладка("Обновить(): бот=%s\tсцена=%v\n", сам.сцена.Бот().Имя(), сам.сцена.Имя())
+	lstString, ош := сам.клиент.Получ(сам.стрУрл)
+	сам.лог.Проверить(ош == nil, "Обновить(): при выполнении запроса, ош=\n\t%v\n", ош)
+	if ош = сам.сцена.СтрОбновить(lstString); ош != nil {
+		сам.лог.Ошибка("Обновить(): при обновлении строк сцены, ош=\n\t%v\n", ош)
+	}
+}
+
+// Get -- выполняет GET-запрос по указанному URL
+func (сам *АренаСеть) Get(strLink string) (lstString []string, err error) {
+	сам.блок.Lock()
+	defer сам.блок.Unlock()
+	// log._rintf("INFO АренаСеть.Get(): link=%v\n", сам.strUrl)
+	if !strings.Contains(strLink, сам.стрУрл) {
+		return nil, fmt.Errorf("АренаСеть.Get(): strLink(%v) не содержит strUrl(%v)", strLink, сам.стрУрл)
+	}
+	lstString, err = сам.клиент.Получ(strLink)
+	if err != nil {
+		return nil, fmt.Errorf("АренаСеть.Get(): err=\n\t%v", err)
+	}
+	return lstString, nil
+}

pkg/components/scene_net/scene_web_worker/scene_web_worker.go → pkg/components/arena_net/scene_web_worker/scene_web_worker.go

@@ -3,10 +3,8 @@ package scene_web_worker
 
 import (
 	"fmt"
-	"log"
 	"sync"
-
-	"wartank/pkg/components/scene_net/netstat"
+	"wartank/pkg/components/kernel/logger"
 	"wartank/pkg/types"
 )
 
@@ -16,18 +14,20 @@ import (
 
 // СценаВебВоркер -- объект сетевого соединения
 type СценаВебВоркер struct {
-	ботСеть    types.ИБотСеть
-	вебВоркер  types.ИВебВоркер
-	статистика *netstat.NetStat
-	block      sync.Mutex
+	ботСеть   types.ИБотСеть
+	вебВоркер types.ИВебВоркер
+	лог       types.ИЛоггер
+	block     sync.Mutex
 }
 
 // НовСценаВебВоркер -- возвращает сетевого клиента
 func НовСценаВебВоркер(ботСеть types.ИБотСеть) *СценаВебВоркер {
+	лог := logger.НовЛоггер("СценаВебВоркер")
+	лог.Инфо("НовСценаВебВоркер()\n")
 	сам := &СценаВебВоркер{
-		ботСеть:    ботСеть,
-		вебВоркер:  ботСеть.ВебВоркер(),
-		статистика: netstat.NewNetStat(ботСеть),
+		ботСеть:   ботСеть,
+		вебВоркер: ботСеть.ВебВоркер(),
+		лог:       лог,
 	}
 	return сам
 }
@@ -37,7 +37,7 @@ func (сам *СценаВебВоркер) Получ(ссылка string) (lst
 	сам.block.Lock()
 	defer сам.block.Unlock()
 	// if ссылка == "https://wartank.ru/production/Mine" {
-	log.Printf("СценаВебВоркер.Получ(): link=%v\n", ссылка)
+	сам.лог.Отладка("СценаВебВоркер.Получ(): link=%v\n", ссылка)
 	// }
 	списОтвет, err := сам.вебВоркер.Получ(ссылка)
 	if err != nil {

pkg/components/scene_net/netstat/netstat.go → pkg/components/arena_net/web_worker/net_stat/net_stat.go

@@ -1,9 +1,10 @@
-package netstat
+// package net_stat -- сетевая статистика по обмену
+package net_stat
 
 import (
-	"log"
 	"sync"
 	"time"
+	"wartank/pkg/components/kernel/logger"
 	"wartank/pkg/types"
 )
 
@@ -11,8 +12,8 @@ import (
 	Сетевая статистика для сетевого соединения
 */
 
-// NetStat -- статистика сетевого соединения
-type NetStat struct {
+// СетьСтата -- статистика сетевого соединения
+type СетьСтата struct {
 	botNet               types.ИБотСеть
 	countByteInterval    int      // Счётчик байтов в текущем интервале
 	totalByte            int      // Сколько всего байт передано
@@ -21,13 +22,17 @@ type NetStat struct {
 	countErr             int      // Число зафиксированных ошибок
 	chTick               chan int // Сигналы времени 1 раз в 5 минут
 	block                sync.Mutex
+	лог                  *logger.Логгер
 }
 
-// NewNetStat -- возвращает новый *NetStat
-func NewNetStat(botNet types.ИБотСеть) *NetStat {
-	сам := &NetStat{
+// НовСетьСтата -- возвращает новый *NetStat
+func НовСетьСтата(botNet types.ИБотСеть) *СетьСтата {
+	лог := logger.НовЛоггер("СетьСтата")
+	лог.Инфо("НовСетьСтата()\n")
+	сам := &СетьСтата{
 		botNet: botNet,
 		chTick: make(chan int, 2),
+		лог:    лог,
 	}
 	go сам.run()
 	go сам.makeTick()
@@ -35,7 +40,7 @@ func NewNetStat(botNet types.ИБотСеть) *NetStat {
 }
 
 // Тикер меток времени 1 раз в 5 минут
-func (сам *NetStat) makeTick() {
+func (сам *СетьСтата) makeTick() {
 	defer close(сам.chTick)
 	for {
 		select {
@@ -49,13 +54,13 @@ func (сам *NetStat) makeTick() {
 }
 
 // Главный цикл работы статистики
-func (сам *NetStat) run() {
+func (сам *СетьСтата) run() {
 	fnCalc := func() {
 		сам.block.Lock()
 		defer сам.block.Unlock()
 		сам.totalMinut += 5
 		mbyte := float32(сам.totalByte) / float32(сам.totalMinut*60) * (3600 * 24 * 30.5) / (1024 * 1024)
-		log.Printf("INFO NetStat.run().fnCalc(): запросы=%0.2f/сек\tтраф0=%0.2f бит/сек\tтраф1=%0.2f МБ/мес\tошибки=%v\n",
+		сам.лог.Инфо("run().fnCalc(): запросы=%0.2f/сек\tтраф0=%0.2f бит/сек\tтраф1=%0.2f МБ/мес\tошибки=%v\n",
 			float32(сам.countRequestInterval)/300,
 			float32(сам.countByteInterval*8)/300,
 			mbyte,
@@ -74,14 +79,14 @@ func (сам *NetStat) run() {
 }
 
 // IncErr -- добавляет ошибку в статистику
-func (сам *NetStat) IncErr() {
+func (сам *СетьСтата) IncErr() {
 	сам.block.Lock()
 	defer сам.block.Unlock()
 	сам.countErr++
 }
 
 // AddByte -- увеличивает счётчик запросов и байтов на передачу/приём
-func (сам *NetStat) AddByte(val int) {
+func (сам *СетьСтата) AddByte(val int) {
 	сам.block.Lock()
 	defer сам.block.Unlock()
 	сам.countByteInterval += val

pkg/components/scene_net/web_worker/web_worker.go → pkg/components/arena_net/web_worker/web_worker.go

@@ -5,30 +5,35 @@ import (
 	"context"
 	"fmt"
 	"io"
-	"log"
 	"net/http"
 	"strings"
 	"sync"
 	"time"
-	"wartank/pkg/components/scene_net/netstat"
+	"wartank/pkg/components/arena_net/web_worker/net_stat"
+	"wartank/pkg/components/kernel/logger"
 	"wartank/pkg/types"
 )
 
-// ВебВоркер -- объект сетевого испонлителя бота
+// ВебВоркер -- объект сетевого исполнителя бота
 type ВебВоркер struct {
 	botNet     types.ИБотСеть
 	conn       *http.Client
-	статистика *netstat.NetStat
+	статистика *net_stat.СетьСтата
+	лог        types.ИЛоггер
 	block      sync.Mutex
 }
 
 // НовВебВоркер -- возвращает веб-воркера бота
-func НовВебВоркер(botNet types.ИБотСеть, conn *http.Client) types.ИВебВоркер {
+func НовВебВоркер(botNet types.ИБотСеть, conn *http.Client) *ВебВоркер {
+	лог := logger.НовЛоггер("ВебВоркер")
+	лог.Инфо("НовВебВоркер()\n")
 	сам := &ВебВоркер{
 		botNet:     botNet,
 		conn:       conn,
-		статистика: netstat.NewNetStat(botNet),
+		статистика: net_stat.НовСетьСтата(botNet),
+		лог:        лог,
 	}
+	_ = types.ИВебВоркер(сам)
 	return сам
 }
 
@@ -37,7 +42,7 @@ func (сам *ВебВоркер) Получ(strLink string) ([]string, error) {
 	сам.block.Lock()
 	defer сам.block.Unlock()
 	// if strLink == "https://wartank.ru/production/Mine" {
-	log.Printf("ВебВоркер.Получ(): link=%v\n", strLink)
+	сам.лог.Отладка("Получ(): link=%v\n", strLink)
 	// }
 	ctxCancel, fnCancel := context.WithTimeout(сам.botNet.Контекст(), time.Second*10)
 	defer fnCancel()
@@ -46,7 +51,7 @@ func (сам *ВебВоркер) Получ(strLink string) ([]string, error) {
 		сам.статистика.IncErr()
 		return nil, fmt.Errorf("ВебВоркер.Получ(): при создании запроса, err=\n\t%w", ош)
 	}
-	запрос.Header.Set("User-Agent", "Mozilla Firefox 94.1")
+	запрос.Header.Set("User-Agent", "Mozilla Firefox 106.1")
 	ответ, ош := сам.conn.Do(запрос)
 	if ош != nil {
 		сам.статистика.IncErr()

pkg/components/kernel/keeper/keeper.go

@@ -18,7 +18,7 @@ import (
 // Сторож -- сторож системных и внутренних сигналов
 type Сторож struct {
 	kernel types.ИЯдро
-	слог   types.ИСлог
+	слог   types.ИЛоггер
 	chSys  chan os.Signal
 }
 

pkg/components/kernel/kernel.go

@@ -5,11 +5,9 @@ package kernel
 
 import (
 	"context"
-	"fmt"
 	"sync"
-
 	"wartank/pkg/components/kernel/keeper"
-	"wartank/pkg/components/kernel/slog"
+	"wartank/pkg/components/kernel/logger"
 	"wartank/pkg/components/kernel/store"
 	"wartank/pkg/components/kernel/wgname"
 	"wartank/pkg/types"
@@ -25,35 +23,33 @@ type Ядро struct {
 	ctxApp   context.Context  // Отменяемый контекст приложения
 	fnCancel func()           // Функция отмены приложения
 	keeper   *keeper.Сторож   // Сторож системных сигналов
-	слог     *slog.Слог       // Логгер в два вывода
+	лог      types.ИЛоггер    // Логгер в два вывода
 	wg       *wgname.WgName   // Групповое ожидание частей приложения
 	хран     types.ИХранилище // Хранилище данных
 	блок     sync.Mutex
 }
 
 // НовЯдро -- возвращает новый *Ядро
-func НовЯдро() (types.ИЯдро, error) {
+func НовЯдро() types.ИЯдро {
+	лог := logger.НовЛоггер("Ядро")
+	лог.Инфо("НовЯдро()\n")
 	// timeStart := time.Now().UTC().Format("2006-10-02 15:04:05.000")
 	// fmt._rintf("%v\t%v\tCI/CD test\n", cons.SelfName, timeStart)
 	сам := &Ядро{
 		ctxBg: context.Background(),
 		wg:    wgname.NewWgName(),
+		лог:   лог,
 	}
 	var ош error
 	сам.ctxApp, сам.fnCancel = context.WithCancel(сам.ctxBg)
 	сам.хран, ош = store.НовХранилище(сам, "./store")
-	if ош != nil {
-		return nil, fmt.Errorf("НовЯдро(): in creste IStore, err=%w", ош)
-	}
+	сам.лог.Проверить(сам.хран != nil, "НовЯдро(): in creste IStore, ош=\n\t%v\n", ош)
 	сам.блок.Lock()
-	сам.слог, ош = slog.НовСлог(сам)
+	сам.лог = logger.НовЛоггер("Ядро")
 	сам.блок.Unlock()
-	if ош != nil {
-		return nil, fmt.Errorf("НовЯдро(): in creste ISlog, err=%w", ош)
-	}
-	сам.слог.Отладка("НовЯдро()")
+	сам.лог.Отладка("НовЯдро()")
 	сам.keeper = keeper.НовСторож(сам)
-	return сам, nil
+	return сам
 }
 
 // Хранилище -- возвращает хранилище данных
@@ -80,11 +76,11 @@ func (сам *Ядро) Done() <-chan struct{} {
 func (сам *Ядро) Отменить() {
 	сам.блок.Lock()
 	defer сам.блок.Unlock()
-	сам.слог.Инфо("Kernel.CancelApp()\n")
+	сам.лог.Инфо("Kernel.CancelApp()\n")
 	сам.fnCancel()
 }
 
 // Слог -- возвращает глобальный лог приложения
-func (сам *Ядро) Слог() types.ИСлог {
-	return сам.слог
+func (сам *Ядро) Слог() types.ИЛоггер {
+	return сам.лог
 }

pkg/components/kernel/kernel_test.go

@@ -24,10 +24,7 @@ func TestKernel(t *testing.T) {
 // Создание базового объекта
 func (сам *tester) create() {
 	сам.t.Logf("create\n")
-	сам.kern, сам.err = НовЯдро()
-	if сам.err != nil {
-		сам.t.Errorf("create(): err=\n\t%v", сам.err)
-	}
+	сам.kern = НовЯдро()
 	if сам.kern == nil {
 		сам.t.Errorf("create(): kernel==nil\n")
 	}

pkg/components/kernel/logger/logger.go

@@ -0,0 +1,59 @@
+// package logger -- логгер
+package logger
+
+import (
+	"fmt"
+	"sync"
+	"wartank/pkg/types"
+)
+
+var блок sync.Mutex
+
+type Логгер struct {
+	префикс string
+}
+
+func НовЛоггер(префикс string) *Логгер {
+	сам := &Логгер{
+		префикс: префикс,
+	}
+	_ = types.ИЛоггер(сам)
+	return сам
+}
+
+// Проверить -- проверяет на совпадение условия
+func (сам *Логгер) Проверить(условие bool, формат string, аргументы ...interface{}) {
+	блок.Lock()
+	defer блок.Unlock()
+	if !условие {
+		panic(fmt.Sprintf("ПАНИК "+сам.префикс+"."+формат, аргументы...))
+	}
+}
+
+// Ошибка -- выводит в консоль ошибку
+func (сам *Логгер) Ошибка(формат string, аргументы ...interface{}) {
+	блок.Lock()
+	defer блок.Unlock()
+	fmt.Printf("ОШИБК "+сам.префикс+"."+формат, аргументы...)
+}
+
+// Отладка -- выводит в консоль отладку
+func (сам *Логгер) Отладка(формат string, аргументы ...interface{}) {
+	блок.Lock()
+	defer блок.Unlock()
+	fmt.Printf("ОТЛАД "+сам.префикс+"."+формат, аргументы...)
+}
+
+// Инфо -- выводит в консоль информацию
+func (сам *Логгер) Инфо(формат string, аргументы ...interface{}) {
+	блок.Lock()
+	defer блок.Unlock()
+	fmt.Printf("ИНФО  "+сам.префикс+"."+формат, аргументы...)
+}
+
+// Внимание -- выводит в консоль предупреждение
+func (сам *Логгер) Внимание(формат string, аргументы ...interface{}) {
+	блок.Lock()
+	defer блок.Unlock()
+	fmt.Printf("ВНИМА "+сам.префикс+"."+формат, аргументы...)
+}

pkg/components/kernel/slog/slog.go

@@ -6,7 +6,6 @@ import (
 	"strings"
 	"sync"
 	"time"
-
 	"wartank/pkg/components/kernel/slog/slog_file"
 	"wartank/pkg/components/kernel/slog/slog_term"
 	"wartank/pkg/components/safe_bool"
@@ -62,9 +61,17 @@ func НовСлог(kern types.ИЯдро) (*Слог, error) {
 		return nil, fmt.Errorf("НовСлог(): при добавлении группы ожидания %q, ош=\n\t%w", strSlog, ош)
 	}
 	сам.Инфо("НовСлог()\n")
+	_ = types.ИЛоггер(сам)
 	return сам, nil
 }
 
+// Проверить -- проверяет на правильное утверждение
+func (сам *Слог) Проверить(усл bool, формат string, значения ...interface{}) {
+	if !усл {
+		panic(fmt.Sprintf(формат, значения...))
+	}
+}
+
 // Отладка -- выводит в лог отладочную инфу
 func (сам *Слог) Отладка(str string, lstVal ...interface{}) {
 	сам.block.Lock()

pkg/components/kernel/store/CURRENT

@@ -1 +1 @@
-MANIFEST-000000
+MANIFEST-000003

pkg/components/kernel/store/CURRENT.bak

@@ -0,0 +1 @@
+MANIFEST-000000

pkg/components/kernel/store/LOG

@@ -6,3 +6,14 @@
 15:59:38.284710 db@open done T·10.417468ms
 15:59:38.293954 db@close closing
 15:59:38.294341 db@close done T·164.877µs
+=============== Sep 2, 2024 (MSK) ===============
+19:14:25.534183 log@legend F·NumFile S·FileSize N·Entry C·BadEntry B·BadBlock Ke·KeyError D·DroppedEntry L·Level Q·SeqNum T·TimeElapsed
+19:14:25.534843 version@stat F·[] S·0B[] Sc·[]
+19:14:25.534922 db@open opening
+19:14:25.535157 journal@recovery F·1
+19:14:25.536118 journal@recovery recovering @1
+19:14:25.537207 version@stat F·[] S·0B[] Sc·[]
+19:14:25.541329 db@janitor F·2 G·0
+19:14:25.541485 db@open done T·6.522387ms
+19:14:25.544015 db@close closing
+19:14:25.544337 db@close done T·260.531µs

pkg/components/kernel/store/store.go

@@ -3,14 +3,13 @@ package store
 
 import (
 	"fmt"
-	"log"
 	"sync"
+	"wartank/pkg/components/kernel/logger"
+	"wartank/pkg/components/safe_bool"
+	"wartank/pkg/types"
 
 	"github.com/syndtr/goleveldb/leveldb"
 	"github.com/syndtr/goleveldb/leveldb/util"
-
-	"wartank/pkg/components/safe_bool"
-	"wartank/pkg/types"
 )
 
 const (
@@ -20,30 +19,26 @@ const (
 // Хранилище -- главный тип плагина хранилища
 type Хранилище struct {
 	ядро   types.ИЯдро
-	path   string              // Путь к хранилищу
+	genm   string              // Путь к хранилищу
 	isWork *safe_bool.БезопБул // Признак открытой базы
 	бд     *leveldb.DB         // Объект хранилища
-	block  sync.Mutex          // Блокировка для безопасности потоков
+	блок   sync.Mutex          // Блокировка для безопасности потоков
+	лог    types.ИЛоггер
 }
 
 // НовХранилище -- возвращает новое хранилище
-func НовХранилище(ядро types.ИЯдро, path string) (*Хранилище, error) {
-	{ // Прдусловия
-		if ядро == nil {
-			return nil, fmt.Errorf("НовХранилище: ядро == nil")
-		}
-		if path == "" {
-			return nil, fmt.Errorf("НовХранилище: path == nil")
-		}
-	}
+func НовХранилище(ядро types.ИЯдро, путь string) (*Хранилище, error) {
+	лог := logger.НовЛоггер("Хранилище")
+	лог.Инфо("НовХранилище()\n")
+	лог.Проверить(ядро != nil, "НовХранилище(): ИЯдро == nil\n")
+	лог.Проверить(путь != "", "НовХранилище(): путь пустой\n")
 	сам := &Хранилище{
 		ядро:   ядро,
-		path:   path,
+		genm:   путь,
 		isWork: safe_bool.НовБезопБул(),
+		лог:    лог,
 	}
-	if err := сам.открыть(); err != nil {
-		return nil, fmt.Errorf("НовХранилище: при открытии БД, err=\n\t%w", err)
-	}
+	сам.открыть()
 	if ош := ядро.Wg().Add(стрХранилище); ош != nil {
 		return nil, fmt.Errorf("НовХранилище: при добавлении группы ожидания, ош=\n\t%v", ош)
 	}
@@ -53,8 +48,8 @@ func НовХранилище(ядро types.ИЯдро, path string) (*Хран
 
 // Уст -- добавляет в хранилище значение по ключу
 func (сам *Хранилище) Уст(ключ string, знач []byte) error {
-	сам.block.Lock()
-	defer сам.block.Unlock()
+	сам.блок.Lock()
+	defer сам.блок.Unlock()
 	if ключ == "" {
 		return fmt.Errorf("Хранилище.Уст(): ключ пустой")
 	}
@@ -68,10 +63,10 @@ func (сам *Хранилище) Уст(ключ string, знач []byte) error
 }
 
 // Получ -- возвращает значение по ключу
-func (sf *Хранилище) Получ(key string) ([]byte, error) {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	value, err := sf.бд.Get([]byte(key), nil)
+func (sf *Хранилище) Получ(ключ string) ([]byte, error) {
+	sf.блок.Lock()
+	defer sf.блок.Unlock()
+	value, err := sf.бд.Get([]byte(ключ), nil)
 	if err != nil {
 		return nil, fmt.Errorf("Хранилище.Get(): in get value, err=\n\t%w", err)
 	}
@@ -80,8 +75,8 @@ func (sf *Хранилище) Получ(key string) ([]byte, error) {
 
 // Найти -- возвращает список ключей по префиксу
 func (sf *Хранилище) Найти(prefix string) ([]string, error) {
-	sf.block.Lock()
-	defer sf.block.Unlock()
+	sf.блок.Lock()
+	defer sf.блок.Unlock()
 	var keys []string
 	slice := &util.Range{Start: []byte(prefix)}
 	iter := sf.бд.NewIterator(slice, nil)
@@ -98,8 +93,8 @@ func (sf *Хранилище) Найти(prefix string) ([]string, error) {
 
 // Удалить -- удаляет значение по ключу
 func (sf *Хранилище) Удалить(key string) error {
-	sf.block.Lock()
-	defer sf.block.Unlock()
+	sf.блок.Lock()
+	defer sf.блок.Unlock()
 	if err := sf.бд.Delete([]byte(key), nil); err != nil {
 		return fmt.Errorf("Хранилище.Del(): in delete key, err=\n\t%w", err)
 	}
@@ -107,10 +102,10 @@ func (sf *Хранилище) Удалить(key string) error {
 }
 
 // открыть -- открывает хранилище
-func (сам *Хранилище) открыть() error {
-	сам.block.Lock()
-	defer сам.block.Unlock()
-	бд, ош := leveldb.OpenFile(сам.path, nil)
+func (сам *Хранилище) открыть() {
+	сам.блок.Lock()
+	defer сам.блок.Unlock()
+	бд, ош := leveldb.OpenFile(сам.genm, nil)
 	фнОткрыть := func() {
 		сам.бд = бд
 		сам.isWork.Уст()
@@ -118,29 +113,22 @@ func (сам *Хранилище) открыть() error {
 	}
 	if ош == nil {
 		фнОткрыть()
-		return nil
-	}
-	log.Printf("Хранилище.открыть(): при открытии БД, ош=\n\t%v", ош)
-	бд, ош = leveldb.RecoverFile(сам.path, nil)
-	if ош != nil {
-		return fmt.Errorf("Хранилище.открыть(): при попытке восстановлении БД, ош=\n\t%w", ош)
+		return
 	}
+	сам.лог.Внимание("Хранилище.открыть(): при открытии БД, ош=\n\t%v\n", ош)
+	бд, ош = leveldb.RecoverFile(сам.genm, nil)
+	сам.лог.Проверить(ош == nil, "Хранилище.открыть(): при восстановлении БД, ош=\n\t%v\n", ош)
 	фнОткрыть()
-	return nil
 }
 
 // закрыть -- закрывает хранилище по требованию
-func (sf *Хранилище) закрыть() {
-	<-sf.ядро.Контекст().Done()
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	sf.isWork.Сброс()
-	if err := sf.бд.Close(); err != nil {
-		log.Printf("Хранилище.закрыть(): при закрытти БД, err=\n\t%v", err)
-		return
-	}
-	ош := sf.ядро.Wg().Done(стрХранилище)
-	if ош != nil {
-		log.Printf("Хранилище.закрыть(): при удалении группы ожидания, ош=\n\t%v", ош)
-	}
+func (сам *Хранилище) закрыть() {
+	<-сам.ядро.Контекст().Done()
+	сам.блок.Lock()
+	defer сам.блок.Unlock()
+	сам.isWork.Сброс()
+	err := сам.бд.Close()
+	сам.лог.Проверить(err == nil, "Хранилище.закрыть(): при закрытии БД, err=\n\t%v\n", err)
+	ош := сам.ядро.Wg().Done(стрХранилище)
+	сам.лог.Проверить(ош == nil, "Хранилище.закрыть(): при удалении группы ожидания, ош=\n\t%v\n", ош)
 }

pkg/components/lst_string/lst_string.go

@@ -1,62 +0,0 @@
-// package lst_string -- потокобезопасный компонент списка строк для анализа объектов
-package lst_string
-
-import (
-	"fmt"
-	"strings"
-	"sync"
-)
-
-// LstString -- потокобезопасный список строк объекта
-type LstString struct {
-	val        []string
-	strControl string // Контрольная строка в исходной строке для анализа
-	block      sync.RWMutex
-}
-
-// NewLstString -- возвращает новый потокобезопасный список строк
-func NewLstString(strControl string) (*LstString, error) {
-	if strControl == "" {
-		return nil, fmt.Errorf("NewLstString(): strControl is empty")
-	}
-	сам := &LstString{
-		val:        make([]string, 0),
-		strControl: strControl,
-	}
-	return сам, nil
-}
-
-// Get -- возвращает список строк для анализа
-func (сам *LstString) Get() []string {
-	сам.block.RLock()
-	defer сам.block.RUnlock()
-	return сам.val
-}
-
-// Set -- устанавливает список строк для анализа
-func (сам *LstString) Set(lstString []string) error {
-	сам.block.Lock()
-	defer сам.block.Unlock()
-	if lstString == nil {
-		return fmt.Errorf("LstString.Set(): lstString is nil")
-	}
-	isOk := false
-	for _, strControl := range lstString {
-		if strings.Contains(strControl, сам.strControl) {
-			isOk = true
-			break
-		}
-	}
-	if isOk {
-		сам.val = lstString
-		return nil
-	}
-	// Найти заголовок
-	var strOut string
-	for _, strOut = range lstString {
-		if strings.Contains(strOut, "<title>") {
-			break
-		}
-	}
-	return fmt.Errorf("LstString.Set(): lstString не имеет правильный title(%q), фактически(%q)", сам.strControl, strOut)
-}

pkg/components/parser_time/parser_time.go → pkg/components/product/parser_time/parser_time.go

@@ -4,11 +4,10 @@ import (
 	"fmt"
 	"strings"
 	"sync"
-
 	"wartank/pkg/alias"
-	"wartank/pkg/components/parser_time/parse_hour"
-	"wartank/pkg/components/parser_time/parse_min"
-	"wartank/pkg/components/parser_time/parse_sec"
+	"wartank/pkg/components/product/parser_time/parse_hour"
+	"wartank/pkg/components/product/parser_time/parse_min"
+	"wartank/pkg/components/product/parser_time/parse_sec"
 	"wartank/pkg/types"
 )
 

pkg/components/product/product.go

@@ -2,7 +2,7 @@
 package product
 
 import (
-	"wartank/pkg/components/parser_time"
+	"wartank/pkg/components/product/parser_time"
 	"wartank/pkg/components/safe_int"
 	"wartank/pkg/components/safe_string"
 	"wartank/pkg/types"

pkg/components/scene_net/section_net.go

@@ -1,80 +0,0 @@
-// package scene_net -- сетевая сцена
-package scene_net
-
-import (
-	"fmt"
-	"log"
-	"strings"
-	"sync"
-
-	// "time"
-
-	"wartank/pkg/types"
-)
-
-// СекцияСеть -- базовый тип для сетевых сцен
-type СценаСеть struct {
-	types.ИБотСеть
-	клиент types.ИВебВоркер
-	секция types.ИСценаСтр
-	стрУрл string
-	блок   sync.Mutex
-}
-
-// НовСекцияСеть -- возвращает новый *СекцияСеть
-func НовСекцияСеть(сцена types.ИСценаСтр, стрУрл string) (*СценаСеть, error) {
-	log.Printf("НовСекцияСеть(): url=%q\n", стрУрл)
-	{ // Предусловия
-		if сцена == nil {
-			return nil, fmt.Errorf("НовСекцияСеть(): ISection == nil")
-		}
-		if стрУрл == "" {
-			return nil, fmt.Errorf("НовСекцияСеть(): strUrl is empty")
-		}
-	}
-	сам := &СценаСеть{
-		ИБотСеть: сцена.Бот().Сеть(),
-		секция:   сцена,
-		стрУрл:   стрУрл,
-		клиент:   сцена.Бот().Сеть().ВебВоркер(),
-	}
-	return сам, nil
-}
-
-// Обновить -- обновляет список строк
-func (сам *СценаСеть) Обновить() error {
-	if сам == nil {
-		return fmt.Errorf("СценаСеть.Обновить(): нет объекта СценаСеть")
-	}
-	сам.блок.Lock()
-	defer сам.блок.Unlock()
-	// FIXME: попытка разобраться, что за фигня творится
-	// time.Sleep(time.Millisecond * 500)
-	log.Printf("СценаСеть.Обновить(): bot=%s\tsection=%v\n", сам.секция.Бот().Имя(), сам.секция.Имя())
-	if сам.секция.Имя() == "Арсенал" {
-		log.Printf("СекцияСеть.Обновить(): арсенал\n")
-	}
-	lstString, err := сам.клиент.Получ(сам.стрУрл)
-	if err != nil {
-		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 nil
-}
-
-// Get -- выполняет GET-запрос по указанному URL
-func (сам *СценаСеть) Get(strLink string) (lstString []string, err error) {
-	сам.блок.Lock()
-	defer сам.блок.Unlock()
-	// log._rintf("INFO СценаСеть.Get(): link=%v\n", сам.strUrl)
-	if !strings.Contains(strLink, сам.стрУрл) {
-		return nil, fmt.Errorf("СценаСеть.Get(): strLink(%v) не содержит strUrl(%v)", strLink, сам.стрУрл)
-	}
-	lstString, err = сам.клиент.Получ(strLink)
-	if err != nil {
-		return nil, fmt.Errorf("СценаСеть.Get(): err=\n\t%v", err)
-	}
-	return lstString, nil
-}

pkg/components/web_log/web_log.go

@@ -6,7 +6,6 @@ import (
 	"strings"
 	"sync"
 	"time"
-
 	"wartank/pkg/types"
 )
 
@@ -23,7 +22,7 @@ func НовВебЛог(еслиПеч bool) types.ИВебЛог {
 		лог:     []string{},
 		еслиПеч: еслиПеч,
 	}
-
+	_ = types.ИВебЛог(сам)
 	return сам
 }
 

pkg/components/wrag/wrag.go

@@ -1,10 +1,9 @@
 package wrag
 
 import (
-	"log"
-
 	"strconv"
 	"strings"
+	"wartank/pkg/components/kernel/logger"
 	"wartank/pkg/types"
 )
 
@@ -12,23 +11,27 @@ import (
 	Танк враг на битве, сражении, дуэли, войне
 */
 
-// Wrag -- объект врага
-type Wrag struct {
-	app    types.ИСервер
+// Враг -- объект врага
+type Враг struct {
+	сервер types.ИСервер
+	лог    types.ИЛоггер
 	health int // здоровье вражины
 }
 
-// NewWrag -- возвращает новый объект врага
-func NewWrag(app types.ИСервер, lstBattle []string) *Wrag {
-	сам := &Wrag{
-		app: app,
+// НовВраг -- возвращает новый объект врага
+func НовВраг(app types.ИСервер, lstBattle []string) *Враг {
+	лог := logger.НовЛоггер("Враг")
+	лог.Отладка("НовВраг()\n")
+	сам := &Враг{
+		сервер: app,
+		лог:    лог,
 	}
 	сам.update(lstBattle)
 	return сам
 }
 
 // Обновляет вражину
-func (сам *Wrag) update(lstBattleOn []string) {
+func (сам *Враг) update(lstBattleOn []string) {
 	// <img class="tank-img" src="/tankimg?c=2&amp;k=1&amp;m=0-2,1-2,2-0,3-2,5-2,6-0&amp;t=png" alt="Тень Брата">
 	var (
 		ind         int
@@ -46,7 +49,7 @@ func (сам *Wrag) update(lstBattleOn []string) {
 		}
 	}
 	if !еслиНайдено { // Не нашёл метку врага
-		log.Printf("Wrag.update(): не нашёл имя врага")
+		сам.лог.Ошибка("update(): не нашёл метку врага\n")
 		сам.health = 800
 		return
 	}
@@ -59,7 +62,7 @@ func (сам *Wrag) update(lstBattleOn []string) {
 	strHealth = lstHealth[0]
 	iHealth, err := strconv.Atoi(strHealth)
 	if err != nil {
-		log.Printf("Wrag.update(): здоровье(%v) не число, err=\n\t%v\n", strHealth, err)
+		сам.лог.Ошибка("update(): здоровье(%v) не число, err=\n\t%v\n", strHealth, err)
 		сам.health = 800
 		return
 	}

pkg/cons/cons.go

@@ -14,10 +14,10 @@ const ( // Задержки для работы
 )
 
 const ( // Режимы работы
-	РежимНеСуществует = alias.СценаРежим("режим_не_существует")
-	РежимАпгрейд      = alias.СценаРежим("режим_апгрейд")
-	РежимОжидание     = alias.СценаРежим("режим_ожидание")
-	РежимРабота       = alias.СценаРежим("режим_работа")
+	РежимНеСуществует = alias.АренаСостояние("режим_не_существует")
+	РежимАпгрейд      = alias.АренаСостояние("режим_апгрейд")
+	РежимОжидание     = alias.АренаСостояние("режим_ожидание")
+	РежимРабота       = alias.АренаСостояние("режим_работа")
 )
 
 // const (

pkg/mock/mockkernel/mockkernel.go

@@ -22,7 +22,7 @@ type MockKernel struct {
 	ctxApp   context.Context // глобальный отменяемый контекст приложения
 	fnCancel func()          // Функия глобальной отмены контекста приложения
 	wg       *wgname.WgName  // Объект группового ожидания
-	Slog_    types.ИСлог     // Двойной логер
+	Slog_    types.ИЛоггер   // Двойной логер
 }
 
 // NewMockKernel -- возвращает новый *MockKernel
@@ -62,6 +62,6 @@ func (сам *MockKernel) Отменить() {
 }
 
 // Слог -- возвращает хранимый логгер
-func (сам *MockKernel) Слог() types.ИСлог {
+func (сам *MockKernel) Слог() types.ИЛоггер {
 	return сам.Slog_
 }

pkg/net_msg/msg_arsenal.go

@@ -0,0 +1,10 @@
+package net_msg
+
+// СбщАрсенал -- сообщение для данных арсенала
+type СбщАрсенал struct {
+	ВремяОбрат_ string `json:"t,omitempty"` // Время до окончания производства арсенала
+	Ремки_      int    `json:"r,omitempty"` // Количество ремок
+	Броньки_    int    `json:"a,omitempty"` // Бронебойные снаряды
+	Кумули_     int    `json:"k,omitempty"` // Кумулятивные снаряды
+	Фугасы_     int    `json:"f,omitempty"` // Фугасные снаряды
+}

pkg/net_msg/msg_mine.go

@@ -0,0 +1,11 @@
+package net_msg
+
+// СбщШахта -- ообщение для данных шахты
+type СбщШахта struct {
+	Руда_       int    `json:"r,omitempty"` // Руда шахты
+	Железо_     int    `json:"f,omitempty"` // Железо шахты
+	Сталь_      int    `json:"s,omitempty"` // Сталь шахты
+	Свинец_     int    `json:"p,omitempty"` // Свинец шахты
+	ВремяОстат_ string `json:"t,omitempty"` // Время производства
+	Режим_      string `json:"m,omitempty"` // Режим производства
+}

pkg/net_msg/msg_resource.go

@@ -0,0 +1,10 @@
+// package net_msg -- сетевые сообщения
+package net_msg
+
+// СбщРесурсы -- сообщение для ресурсов
+type СбщРесурсы struct {
+	Слава_   int `json:"a,omitempty"` // Слава танка
+	Серебро_ int `json:"s,omitempty"` // Всё серебро танка
+	Золото_  int `json:"g,omitempty"` // Всё золото танка
+	Топливо_ int `json:"f,omitempty"` // Всё топливо танка
+}

pkg/net_struct/net_arsenal.go

@@ -1,10 +0,0 @@
-package net_struct
-
-// Arsenal -- стрктура для хранения данных арсенала
-type Arsenal struct {
-	Time  string `json:"t,omitempty"` // Время до окончания производства арсенала
-	Remka int    `json:"r,omitempty"` // Количество ремок
-	Armor int    `json:"a,omitempty"` // Бронебойные снаярды
-	Kumul int    `json:"k,omitempty"` // Кумулятивные снаряды
-	Fugas int    `json:"f,omitempty"` // Фугасные снаряды
-}

pkg/net_struct/net_mine.go

@@ -1,11 +0,0 @@
-package net_struct
-
-// Mine -- стрктура для хранения данных шахты
-type Mine struct {
-	Ruda    int    `json:"r,omitempty"` // Руда шахты
-	Ferrum  int    `json:"f,omitempty"` // Железо шахты
-	Steel   int    `json:"s,omitempty"` // Сталь шахты
-	Plumbum int    `json:"p,omitempty"` // Свинец шахты
-	Time    string `json:"t,omitempty"` // Время производства
-	Mode    string `json:"m,omitempty"` // Режим производства
-}

pkg/net_struct/net_resource.go

@@ -1,10 +0,0 @@
-// package net_struct -- сетевые структуры обмена
-package net_struct
-
-// Resource -- стрктура для хранения ресурсов
-type Resource struct {
-	Glory  int `json:"a,omitempty"` // Слава танка
-	Silver int `json:"s,omitempty"` // Всё серебро танка
-	Gold   int `json:"g,omitempty"` // Всё золото танка
-	Fuel   int `json:"f,omitempty"` // Всё топливо танка
-}

pkg/scene/scene.go

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

pkg/scene/scene_mode/scene_mode.go

@@ -1,49 +0,0 @@
-// 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/section/section.go

@@ -1,80 +0,0 @@
-// package section -- типовая секция работы части игры (банк, арсенал и т.п.)
-package section
-
-import (
-	"fmt"
-	"log"
-	"sync"
-
-	"wartank/pkg/alias"
-	"wartank/pkg/components/lst_string"
-	"wartank/pkg/scene"
-	"wartank/pkg/section/down_time"
-	"wartank/pkg/types"
-)
-
-// Секция -- секция игры
-type Секция struct {
-	types.ИСцена
-	времяОстат types.ИВремяОстат     // Обратный отсчёт до окончания работы режима
-	списСтр    *lst_string.LstString // Список строк из сети для анализа секции
-	блок       sync.RWMutex
-}
-
-// НовСекция -- возвращает новую секцию игры
-func НовСекция(бот types.ИБот, сценаИмя alias.СценаИмя, стрКонтроль string) (*Секция, error) {
-	log.Printf("НовСекция(): стрКонтроль=%q\n", стрКонтроль)
-	сцена, ош := scene.НовСцена(бот, сценаИмя)
-	if ош != nil {
-		return nil, fmt.Errorf("НовСекция(): при создании ИСцена, ош=\n\t%w", ош)
-	}
-	сам := &Секция{
-		ИСцена:     сцена,
-		времяОстат: down_time.НовВремОбрат(сцена, 5),
-	}
-	сам.списСтр, ош = lst_string.NewLstString(стрКонтроль)
-	if ош != nil {
-		return nil, fmt.Errorf("НовСекция(): in create *LstString, err=\n\t%w", ош)
-	}
-	return сам, nil
-}
-
-// СтрОбновить -- обновляет список строк секции по требованию
-func (сам *Секция) СтрОбновить(lstString []string) error {
-	if err := сам.списСтр.Set(lstString); err != nil {
-		return fmt.Errorf("Section.СтрОбновить(): при установке lstString, err=\n\t%w", err)
-	}
-	return nil
-}
-
-// СписПолучить -- возвращает список строк секции
-func (сам *Секция) СписПолучить() []string {
-	return сам.списСтр.Get()
-}
-
-// ОбратВремяУст -- устанавливает новое значение обратного счётчика времени
-func (сам *Секция) ОбратВремяУст(время alias.Время) error {
-	ош := сам.времяОстат.Уст(время)
-	if ош != nil {
-		return fmt.Errorf("Секция.ОбратВремяУст(): ош=\n\t%w", ош)
-	}
-	return nil
-}
-
-// Уст -- устанавливает новое значение обратного счётчика времени
-func (сам *Секция) Уст(времяСек alias.Время) error {
-	if ош := сам.времяОстат.Уст(времяСек); ош != nil {
-		return fmt.Errorf("Секция.ParseCountDown(): err=\n\t%w", ош)
-	}
-	// if err := сам.countDown.Set(sec); err != nil {
-	//
-	// }
-	return nil
-}
-
-// ВремяОстат -- объект оставшегося времени
-func (сам *Секция) ВремяОстат() types.ИВремяОстат {
-	сам.блок.RLock()
-	defer сам.блок.RUnlock()
-	return сам.времяОстат
-}

pkg/types/iarena.go

@@ -0,0 +1,16 @@
+package types
+
+import "wartank/pkg/alias"
+
+// ИАрена -- интерфейс арены
+type ИАрена interface {
+	ИАренаКонтекст
+	// ВремяОстат -- возвращает остаток времени до окончания работы
+	ВремяОстат() ИВремяОстат
+	// СписПолучить -- возвращает список строк арены
+	СписПолучить() []string
+	// СтрОбновить -- обновляет список строк арены
+	СтрОбновить(lstString []string) error
+	// ОбратВремяУст -- устанавливает новое значение обратного счётчика времени
+	ОбратВремяУст(времяСек alias.Время) error
+}

pkg/types/iarena_ctx.go

@@ -0,0 +1,22 @@
+package types
+
+import (
+	"context"
+	"wartank/pkg/alias"
+)
+
+// ИСцИАренаКонтекстена -- контекст игровой арены (ангар, база, битва и т.п.)
+type ИАренаКонтекст interface {
+	// Бот -- возвращает бота игровой арены
+	Бот() ИБот
+	// Контекст -- контекст игровой врены
+	Контекст() context.Context
+	// Отмена -- отмена контекста игровой арены
+	Отмена()
+	// Имя -- имя игровой арены
+	Имя() alias.АренаИмя
+	// АренаСостояние -- состояние арены
+	АренаСостояние() ИАренаСостояние
+	// ВебЛог -- возвращает веб-лог арены
+	ВебЛог() ИВебЛог
+}

pkg/types/iarena_net.go

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

pkg/types/iarena_state.go

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

pkg/types/ibattle_action.go

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

pkg/types/ibot_net.go

@@ -17,9 +17,9 @@ type ИБотСеть interface {
 	Куки() ИБотКуки
 	// ВебВоркер -- возвращает веб-воркер бота
 	ВебВоркер() ИВебВоркер
-	// Кнт -- контекст сетевого клиента
+	// Контекст -- контекст сетевого клиента
 	Контекст() context.Context
-	// Отмена -- вызывает отмену котекста сетевого клиента бота
+	// Отмена -- вызывает отмену контекста сетевого клиента бота
 	Отмена()
 	// Бот -- возвращает ссылку на бота
 	Бот() ИБот

pkg/types/idesktop.go

@@ -2,9 +2,14 @@ package types
 
 import (
 	"wartank/pkg/alias"
-	"wartank/pkg/bot"
 )
 
+// Bot -- объект бота
+type Bot struct {
+	Login_ string
+	Pass_  string
+}
+
 // ИДесктоп -- интерфейс к десктоп-приложению
 type ИДесктоп interface {
 	// УстОкно -- устанавливает окно для показа
@@ -28,7 +33,7 @@ type ИДесктоп interface {
 	// БотПарольУст -- устанавливает пароль текущего бота
 	БотПарольУст(password string)
 	// СписБот -- список ботов из клиента
-	СписБот() []*bot.Bot
+	СписБот() []Bot
 	// БотТекущСтарт -- запускает в работу текущего бота
 	БотТекущСтарт()
 }

pkg/types/idiv_war_action.go

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

pkg/types/ikernel.go

@@ -25,7 +25,7 @@ type ИЯдро interface {
 	// Wg -- возвращает групповой объект ожидания
 	Wg() IWgName
 	// Слог -- возвращает логгер
-	Слог() ИСлог
+	Слог() ИЛоггер
 	// Контекст -- возвращает контекст приложения
 	Контекст() context.Context
 	// Хранилище -- возвращает хранилище

pkg/types/imissions.go

@@ -7,4 +7,6 @@ package types
 // ИМиссии -- интерфейс к объекту миссий
 type ИМиссии interface {
 	ИСценаСтр
+	// Пуск -- запускает в работу миссии
+	Пуск()
 }

pkg/types/iscene.go

@@ -1,22 +0,0 @@
-package types
-
-import (
-	"context"
-	"wartank/pkg/alias"
-)
-
-// ИСцена -- игровая сцена (ангар, база, битва и т.п.)
-type ИСцена interface {
-	// Бот -- возвращает бота игровой сцены
-	Бот() ИБот
-	// Контекст -- контекст игровой зоны
-	Контекст() context.Context
-	// Отмена -- отмена контекста игровой сцены
-	Отмена()
-	// Имя -- имя игровой сцены
-	Имя() alias.СценаИмя
-	// СценаРежим -- текущий режим работы
-	СценаРежим() ИСценаРежим
-	// Лог -- возвращает лог сцены
-	Лог() ИВебЛог
-}

pkg/types/iscene_mode.go

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

pkg/types/iscene_net.go

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

pkg/types/isection.go

@@ -6,7 +6,7 @@ package types
 
 // ИСценаСтр -- интерфейс базового типа любой сцены игры
 type ИСценаСтр interface {
-	ИСцена
+	ИАренаКонтекст
 	// СтрОбновить -- обновляет строки сцены
 	СтрОбновить(lstString []string) error
 	// СписПолучить -- возвращает список строк сцены

pkg/types/islog.go

@@ -5,7 +5,7 @@ package types
 */
 
 // ИСлог -- интерфейс к логирования
-type ИСлог interface {
+type ИЛоггер interface {
 	// Отладка -- отладочный вывод
 	Отладка(str string, lst ...interface{})
 	// Инфо -- информационный дежурный вывод
@@ -14,4 +14,6 @@ type ИСлог interface {
 	Внимание(str string, lst ...interface{})
 	// Ошибка -- вывод ошибки
 	Ошибка(str string, lst ...interface{})
+	// Проверить -- проверяет на правильное утверждение
+	Проверить(усл bool, формат string, значения ...interface{})
 }

server/serv_bots/dict_warbot/dict_warbot.go

@@ -3,12 +3,11 @@ package dict_warbot
 
 import (
 	"fmt"
-	"log"
 	"strconv"
 	"strings"
 	"sync"
-
 	"wartank/pkg/alias"
+	"wartank/pkg/components/kernel/logger"
 	"wartank/pkg/types"
 	"wartank/server/serv_bots/warbot"
 )
@@ -17,85 +16,84 @@ const (
 	strBotList = "/bots/list" // Константа путь к списку ботов в базе
 )
 
-// DictWarBot -- потокобезопасный словарь ботов
-type DictWarBot struct {
-	server types.ИСервер
-	store  types.ИХранилище
-	dict   map[alias.БотНомер]types.ИБот
-	block  sync.RWMutex
+// СловарьБотов -- потокобезопасный словарь ботов
+type СловарьБотов struct {
+	сервер  types.ИСервер
+	хран    types.ИХранилище
+	словарь map[alias.БотНомер]types.ИБот
+	блок    sync.RWMutex
+	лог     types.ИЛоггер
 }
 
-// NewDictWarBot -- возвращает новый потокобезопасный словарь ботов
-func NewDictWarBot(server types.ИСервер) (*DictWarBot, error) {
-	if server == nil {
-		return nil, fmt.Errorf("NewDictWarBot(): IServer==nil")
-	}
-	log.Printf("NewDictWarBot()\n")
-	сам := &DictWarBot{
-		server: server,
-		store:  server.Хранилище(),
-		dict:   map[alias.БотНомер]types.ИБот{},
-	}
-	if err := сам.load(); err != nil {
-		return nil, fmt.Errorf("NewDictBot(): in load list bots from store, err=%w", err)
+// НовСловарьБотов -- возвращает новый потокобезопасный словарь ботов
+func НовСловарьБотов(сервер types.ИСервер) *СловарьБотов {
+	лог := logger.НовЛоггер("СловарьБотов")
+	лог.Инфо("НовСловарьБотов()\n")
+	лог.Проверить(сервер != nil, "НовСловарьБотов(): ИСервер==nil")
+	сам := &СловарьБотов{
+		сервер:  сервер,
+		хран:    сервер.Хранилище(),
+		словарь: map[alias.БотНомер]types.ИБот{},
+		лог:     лог,
 	}
-	return сам, nil
+	сам.load()
+	return сам
 }
 
 // ListBot -- возвращает список существующих ботов
-func (сам *DictWarBot) ListBot() []types.ИБот {
-	сам.block.RLock()
-	defer сам.block.RUnlock()
+func (сам *СловарьБотов) ListBot() []types.ИБот {
+	сам.блок.RLock()
+	defer сам.блок.RUnlock()
 	lst := make([]types.ИБот, 0)
-	for _, bot := range сам.dict {
+	for _, bot := range сам.словарь {
 		lst = append(lst, bot)
 	}
 	return lst
 }
 
 // Get -- возвращает бота по имени
-func (сам *DictWarBot) Get(botNumber alias.БотНомер) types.ИБот {
-	сам.block.RLock()
-	defer сам.block.RUnlock()
-	bot := сам.dict[botNumber]
+func (сам *СловарьБотов) Get(botNumber alias.БотНомер) types.ИБот {
+	сам.блок.RLock()
+	defer сам.блок.RUnlock()
+	bot := сам.словарь[botNumber]
 	return bot
 }
 
 // Add -- добавляет нового бота в словарь
-func (сам *DictWarBot) Add(bot types.ИБот) {
-	сам.block.Lock()
-	defer сам.block.Unlock()
+func (сам *СловарьБотов) Add(bot types.ИБот) {
+	сам.блок.Lock()
+	defer сам.блок.Unlock()
 	if bot == nil {
 		return
 	}
-	сам.dict[bot.Номер()] = bot
+	сам.словарь[bot.Номер()] = bot
 	сам.save()
 }
 
 // Сохраняет словарь ботов в базе
-func (сам *DictWarBot) save() {
+func (сам *СловарьБотов) save() {
 	strNumber := ""
-	for botNumber := range сам.dict {
+	for botNumber := range сам.словарь {
 		strNumber += fmt.Sprint(botNumber) + ";"
 	}
 	strNumber = strNumber[:len(strNumber)-1]
-	err := сам.store.Уст(strBotList, []byte(strNumber))
+	err := сам.хран.Уст(strBotList, []byte(strNumber))
 	if err != nil {
-		сам.server.Отменить()
+		сам.сервер.Отменить()
 	}
 }
 
 // Загружает всех ботов с базы
-func (сам *DictWarBot) load() error {
-	binNumber, err := сам.store.Получ(strBotList)
+func (сам *СловарьБотов) load() {
+	binNumber, err := сам.хран.Получ(strBotList)
 	if err != nil {
 		if !strings.Contains(err.Error(), "not found") {
-			return fmt.Errorf("DictWarBot.load(): in get list bot, err=\n\t%w", err)
+			сам.лог.Проверить(false, "СловарьБотов.load(): при загрзке списка ботов, ош=\n\t%n\t", err)
 		}
 	}
 	strNumbers := string(binNumber)
 	if strNumbers == "" {
-		return nil
+		return
 	}
 	lstNumbers := strings.Split(strNumbers, ";")
 	for _, strNumber := range lstNumbers {
@@ -103,22 +101,17 @@ func (сам *DictWarBot) load() error {
 			continue
 		}
 		iNumber, err := strconv.Atoi(strNumber)
-		if err != nil {
-			return fmt.Errorf("DictWarBot.load(): in conver number bot(%v), err=\n\t%w", strNumber, err)
-		}
+		сам.лог.Проверить(err == nil, "СловарьБотов.load(): при получении номера бота, ош=\n\t%v\n", err)
 		number := alias.БотНомер(iNumber)
-		_, isOk := сам.dict[number]
+		_, isOk := сам.словарь[number]
 		if isOk {
 			continue
 		}
-		bot, err := warbot.ЗагрузитьВарБот(сам.server, number)
-		if err != nil {
-			return fmt.Errorf("ServBots.load(): in create bot %q, err=\n\t%w", strNumber, err)
-		}
+		bot, err := warbot.ЗагрузитьВарБот(сам.сервер, number)
+		сам.лог.Проверить(err == nil, "СловарьБотов.load(): при загрузке бота, ош=\n\t%v\n", err)
 		if bot.АвтоИграЕсли() {
 			go bot.Пуск()
 		}
-		сам.dict[number] = bot
+		сам.словарь[number] = bot
 	}
-	return nil
 }

server/serv_bots/serv_bots.go

@@ -3,7 +3,6 @@ package serv_bots
 
 import (
 	"fmt"
-
 	"wartank/pkg/alias"
 	"wartank/pkg/types"
 	"wartank/server/serv_bots/dict_warbot"
@@ -14,35 +13,31 @@ import (
 type БотоФерма struct {
 	серв    types.ИСервер
 	хран    types.ИХранилище
-	dictBot *dict_warbot.DictWarBot
+	словБот *dict_warbot.СловарьБотов
 }
 
 // НовБотоФерма -- возвращает новый словарь серверных ботов
-func НовБотоФерма(серв types.ИСервер) (*БотоФерма, error) {
-	if серв == nil {
-		return nil, fmt.Errorf("НовБотоФерма(): ИСервер == nil")
-	}
+func НовБотоФерма(серв types.ИСервер) *БотоФерма {
+	лог := серв.Слог()
+	лог.Инфо("НовБотоФерма()\n")
+	лог.Проверить(серв != nil, "НовБотоФерма(): ИСервер == nil")
 	сам := &БотоФерма{
 		серв: серв,
 		хран: серв.Хранилище(),
 	}
-	var ош error
-	сам.dictBot, ош = dict_warbot.NewDictWarBot(серв)
-	if ош != nil {
-		return nil, fmt.Errorf("НовБотоФерма(): in create DictWarBot, err=\n\t%w", ош)
-	}
-	return сам, nil
+	сам.словБот = dict_warbot.НовСловарьБотов(серв)
+	return сам
 }
 
 // Get -- возвращает боевого бота по имени
 func (сам *БотоФерма) Get(botNumber alias.БотНомер) types.ИБот {
-	bot := сам.dictBot.Get(botNumber)
+	bot := сам.словБот.Get(botNumber)
 	return bot
 }
 
 // BotStart -- запускает бота в работу по его имени
 func (сам *БотоФерма) BotStart(botNumber alias.БотНомер) error {
-	bot := сам.dictBot.Get(botNumber)
+	bot := сам.словБот.Get(botNumber)
 	if bot == nil {
 		return fmt.Errorf("ServBots.BotStart(): bot(%v) not found", botNumber)
 	}
@@ -52,22 +47,22 @@ func (сам *БотоФерма) BotStart(botNumber alias.БотНомер) err
 
 // ListBot -- возвращает список существующих ботов
 func (сам *БотоФерма) ListBot() []types.ИБот {
-	lst := сам.dictBot.ListBot()
+	lst := сам.словБот.ListBot()
 	return lst
 }
 
 // НовБот -- добавляет нового бота на ферму
 func (сам *БотоФерма) НовБот(логин, пароль string, еслиАвто bool) error {
 	{ // Существует ли такой бот
-		for _, бот := range сам.dictBot.ListBot() {
+		for _, бот := range сам.словБот.ListBot() {
 			if бот.Имя() == логин {
 				return nil
 			}
 		}
 	}
-	номер := alias.БотНомер(len(сам.dictBot.ListBot()) + 1)
+	номер := alias.БотНомер(len(сам.словБот.ListBot()) + 1)
 	фнНомерПровер := func() bool {
-		for _, бот := range сам.dictBot.ListBot() {
+		for _, бот := range сам.словБот.ListBot() {
 			if бот.Номер() == номер {
 				return false
 			}
@@ -82,7 +77,7 @@ func (сам *БотоФерма) НовБот(логин, пароль string,
 		if err != nil {
 			return fmt.Errorf("БотоФерма.НовБот(): in create bot %q, err=\n\t%w", логин, err)
 		}
-		сам.dictBot.Add(bot)
+		сам.словБот.Add(bot)
 	}
 	return nil
 }

server/serv_bots/warbot/angar/angar.go

@@ -7,9 +7,9 @@ import (
 	"strings"
 	"sync"
 	"time"
-	"wartank/pkg/section"
+	"wartank/pkg/arena"
+	"wartank/pkg/components/arena_net"
 	"wartank/pkg/types"
-	"wartank/server/serv_bots/warbot/angar/angarnet"
 	"wartank/server/serv_bots/warbot/angar/base"
 	"wartank/server/serv_bots/warbot/angar/battle"
 	"wartank/server/serv_bots/warbot/angar/convoy"
@@ -28,9 +28,9 @@ import (
 
 // Ангар -- ангар для танка
 type Ангар struct {
-	*section.Секция
-	слог       types.ИСлог
-	сеть       types.ИСценаСеть
+	types.ИАрена
+	слог       types.ИЛоггер
+	сеть       types.ИАренаСеть
 	топливоБой *fuel_attack.ТопливоБой
 
 	бот      types.ИБот
@@ -38,7 +38,7 @@ type Ангар struct {
 	сражение *battle.Сражение
 	битва    *masters.БитваМастеров
 	база     *base.База
-	миссии   *missions.Миссии
+	миссии   types.ИМиссии
 
 	золото        types.ИСтатПарам
 	уровень       types.ИСтатПарам
@@ -55,12 +55,8 @@ type Ангар struct {
 }
 
 // НовАнгар -- возвращает новый *Angar
-func НовАнгар(bot types.ИБот) (*Ангар, error) {
-	section, err := section.НовСекция(bot, "Ангар", `<title>Ангар</title>`)
-	if err != nil {
-		return nil, fmt.Errorf("НовАнгар(): in create ISection, err=\n\t%w", err)
-	}
-
+func НовАнгар(бот types.ИБот) (*Ангар, error) {
+	арена := arena.НовАрена(бот, "Ангар", `<title>Ангар</title>`)
 	золото, ош := static_param.НовСтатПарам("gold")
 	if ош != nil {
 		return nil, fmt.Errorf("НовАнгар(): при создании статистики золота, ош=\n\t%w", ош)
@@ -85,14 +81,14 @@ func НовАнгар(bot types.ИБот) (*Ангар, error) {
 	if ош != nil {
 		return nil, fmt.Errorf("НовАнгар(): при создании статистики серебра заработанного за сессию, ош=\n\t%w", ош)
 	}
-	танкПарам, ош := tank_params.НовТанкПараметры(bot)
+	танкПарам, ош := tank_params.НовТанкПараметры(бот)
 	if ош != nil {
 		return nil, fmt.Errorf("НовАнгар(): при создании параметров танка, ош=\n\t%w", ош)
 	}
 	сам := &Ангар{
-		Секция:        section,
-		слог:          bot.Сервер().Слог(),
-		бот:           bot,
+		ИАрена:        арена,
+		слог:          бот.Сервер().Слог(),
+		бот:           бот,
 		золото:        золото,
 		уровень:       уровень,
 		progress:      прогресс,
@@ -102,12 +98,8 @@ func НовАнгар(bot types.ИБот) (*Ангар, error) {
 		silverOnline: сереброСессия,
 		танкПарам:    танкПарам,
 	}
-	{ // Сеть
-		сам.сеть, err = angarnet.NewAngarNet(сам)
-		if err != nil {
-			return nil, fmt.Errorf("НовАнгар(): in create <AngarNet>, err=\n\t%w", err)
-		}
-	}
+	сам.сеть = arena_net.НовАренаСеть(сам, "https://wartank.ru/angar")
+	var err error
 	{ // Сеть атаки
 		сам.топливоБой, err = fuel_attack.НовТопливоБой(сам)
 		if err != nil {
@@ -133,10 +125,7 @@ func НовАнгар(bot types.ИБот) (*Ангар, error) {
 		}
 	}
 	{ // Битва мастеров
-		сам.битва, err = masters.НовБитваМастеров(сам.бот)
-		if err != nil {
-			return nil, fmt.Errorf("НовАнгар(): in create *BatMas, err=\n\t%w", err)
-		}
+		сам.битва = masters.НовБитваМастеров(сам.бот)
 		// go сам.batMas.Run()
 	}
 	{ // База
@@ -192,16 +181,14 @@ func (сам *Ангар) Пуск() error {
 		if err := сам.база.Пуск(); err != nil {
 			return fmt.Errorf("Ангар.Пуск(): при пуске базы, err=\n\t%w", err)
 		}
-		if err := сам.миссии.Пуск(); err != nil {
-			return fmt.Errorf("Ангар.Пуск(): при пуске наград, err=\n\t%w", err)
-		}
+		сам.миссии.Пуск()
 		сам.танкПарам.Пуск()
 		go сам.топливо.Run()
 	}
 	фнЦикл := func() bool {
 		сам.Обновить()
 		// сам.конвойПроверить()
-		if err := сам.Секция.ОбратВремяУст("01:00"); err != nil {
+		if err := сам.ОбратВремяУст("01:00"); err != nil {
 			сам.Отмена()
 			log.Printf("Ангар.Run(): in update ICountTime, err=\n\t%v\n", err)
 			return false
@@ -209,7 +196,7 @@ func (сам *Ангар) Пуск() error {
 		return true
 	}
 	go func() {
-		ош := сам.Секция.ОбратВремяУст("01")
+		ош := сам.ОбратВремяУст("01")
 		if ош != nil {
 			сам.слог.Ошибка("Ангар.Run(): in update ICountTime, ош=\n\t%w\n", ош)
 			сам.бот.Сервер().Отменить()
@@ -236,10 +223,7 @@ func (сам *Ангар) Пуск() error {
 
 // Обновляет ресурсы ангара
 func (сам *Ангар) РесурсыОбновить() {
-	if ош := сам.сеть.Обновить(); ош != nil {
-		// log._rintf("ERRO Ангар.updateResurs(): при обработке ангара в сети, err=\n\t%v\n", err)
-		return
-	}
+	сам.сеть.Обновить()
 	сам.золотоНайти()
 	сам.сереброНайти()
 }

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

@@ -1,33 +0,0 @@
-package angarnet
-
-import (
-	"fmt"
-
-	"wartank/pkg/components/scene_net"
-	"wartank/pkg/types"
-)
-
-/*
-	Объект сетевого ангара
-*/
-
-// AngarNet -- объект сетевого ангара
-type AngarNet struct {
-	*scene_net.СценаСеть
-	angar types.ИАнгар
-}
-
-// NewAngarNet -- возвращает новый *AngarNet
-func NewAngarNet(angar types.ИАнгар) (*AngarNet, error) {
-	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)
-	}
-
-	сам := &AngarNet{
-		СценаСеть: sectionNet,
-		angar:     angar,
-	}
-	_ = types.ИСценаСеть(сам)
-	return сам, nil
-}

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

@@ -8,10 +8,11 @@ import (
 	"strconv"
 	"strings"
 	"time"
-
-	"wartank/pkg/section"
+	"wartank/pkg/arena"
+	"wartank/pkg/components/arena_net"
+	"wartank/pkg/components/kernel/logger"
+	"wartank/pkg/components/web_log"
 	"wartank/pkg/types"
-	"wartank/server/serv_bots/warbot/angar/base/arsenal/arsenalnet"
 	"wartank/server/serv_bots/warbot/tank_stat/static_param"
 )
 
@@ -24,11 +25,12 @@ const (
 
 // Арсенал -- объект оружейной на базе
 type Арсенал struct {
-	*section.Секция
-	лог          types.ИВебЛог
+	types.ИАрена
+	вЛог         types.ИВебЛог
+	лог          types.ИЛоггер
 	бот          types.ИБот
 	база         types.ИБаза
-	сеть         *arsenalnet.ArsenalNet
+	сеть         types.ИАренаСеть
 	фугас        types.ИСтатПарам
 	бронебойка   types.ИСтатПарам
 	кумулятив    types.ИСтатПарам
@@ -43,10 +45,9 @@ type Арсенал struct {
 
 // НовАрсенал -- возвращает новый *Arsenal
 func НовАрсенал(база types.ИБаза) (types.ИАрсенал, error) {
-	section, err := section.НовСекция(база.Бот(), "Арсенал", `<span class="green2">Ремкомплект</span><br/>`)
-	if err != nil {
-		return nil, fmt.Errorf("НовАрсенал(): in create ISection, err=\n\t%w", err)
-	}
+	лог := logger.НовЛоггер("Арсенал")
+	лог.Инфо("НовАрсенал()\n")
+	арена := arena.НовАрена(база.Бот(), "Арсенал", `<span class="green2">Ремкомплект</span><br/>`)
 
 	фугас, ош := static_param.НовСтатПарам(стрФугасы)
 	if ош != nil {
@@ -74,7 +75,7 @@ func НовАрсенал(база types.ИБаза) (types.ИАрсенал, er
 	}
 	кнт, фнОтмена := context.WithCancel(база.Контекст())
 	сам := &Арсенал{
-		Секция:     section,
+		ИАрена:     арена,
 		бот:        база.Бот(),
 		база:       база,
 		фугас:      фугас,
@@ -85,16 +86,14 @@ func НовАрсенал(база types.ИБаза) (types.ИАрсенал, er
 		продуктКол: продуктКол,
 		кнт:        кнт,
 		фнОтмена:   фнОтмена,
+
+		лог: лог,
 	}
-	сам.лог = сам.Лог()
-	{ // ArsenalNet
-		сам.сеть, err = arsenalnet.НовАрсеналСеть(сам)
-		if err != nil {
-			return nil, fmt.Errorf("НовАрсенал(): in create NetArsenal, err=\n\t%w", err)
-		}
-	}
+	сам.вЛог = web_log.НовВебЛог(true)
+	сам.сеть = arena_net.НовАренаСеть(сам, "https://wartank.ru/production/Armory")
+	// сам.сеть = arsenalnet.НовАрсеналСеть(сам)
 	go сам.пуск()
-	сам.лог.Добавить("НовАрсенал(): Арсенал создан")
+	сам.вЛог.Добавить("НовАрсенал(): Арсенал создан")
 	return сам, nil
 }
 
@@ -128,7 +127,7 @@ func (сам *Арсенал) пуск() {
 				time.Sleep(time.Second * 5)
 			}
 		}()
-		сам.лог.Добавить("Арсенал.пуск().фнРабота()\n")
+		сам.вЛог.Добавить("Арсенал.пуск().фнРабота()\n")
 		if еслиПостроить {
 			счёт := 5
 			for счёт > 0 {
@@ -155,11 +154,12 @@ func (сам *Арсенал) пуск() {
 		_ = сам.уровеньОбновить()
 		ош := сам.СтатаОбновить()
 		if ош != nil {
-			сам.лог.Добавить("ОШИБКА ArsenalNet.Run(): in update stat, err=\n\t%w", ош)
+			сам.лог.Ошибка("пуск(): при обновлении статы, ош=\n\t%v\n", ош)
+			сам.вЛог.Добавить("пуск(): при обновлении статы, ош=\n\t%w", ош)
 		}
 		сам.забрать()
 		сам.сделать()
-		log.Printf("Арсенал.пуск(): бот=%q, цикл завершён\n", сам.бот.Имя())
+		сам.лог.Инфо("пуск(): бот=%q, цикл завершён\n", сам.бот.Имя())
 	}
 	for {
 		select {
@@ -181,10 +181,11 @@ func (сам *Арсенал) пуск() {
 
 // Обновляет текущий уровень оружейки (может быть не построена)
 func (сам *Арсенал) уровеньОбновить() bool {
-	сам.лог.Добавить("Арсенал.уровеньОбновить()\n")
+	сам.вЛог.Добавить("Арсенал.уровеньОбновить()\n")
 	списСтр, ош := сам.сеть.ВебВоркер().Получ("http://wartank.ru/buildings")
 	if ош != nil {
-		сам.лог.Добавить("ОШИБКА Арсенал.уровеньОбновить(): in make request, err=\n\t%v\n", ош)
+		сам.лог.Ошибка("уровеньОбновить(): при выполнении запроса, ош=\n\t%v\n", ош)
+		сам.вЛог.Добавить("ОШИБКА Арсенал.уровеньОбновить(): in make request, err=\n\t%v\n", ош)
 		return false
 	}
 	// <span class="green2">Оружейная - 0</span><br/>
@@ -199,27 +200,30 @@ func (сам *Арсенал) уровеньОбновить() bool {
 		}
 	}
 	if !еслиНайти {
-		сам.лог.Добавить("Арсенал.уровеньОбновить(): не надо\n")
+		сам.вЛог.Добавить("Арсенал.уровеньОбновить(): не надо\n")
 		return false
 	}
 	_стр := strings.TrimPrefix(стр, `<span class="green2">Оружейная - `)
 	_стр = strings.TrimSuffix(_стр, `</span><br/>`)
 	иУровень, ош := strconv.Atoi(_стр)
 	if ош != nil {
-		сам.лог.Добавить("ОШИБКА Арсенал.уровеньОбновить(): строка уровня сбойная, стр=%q, ош=\n\t%v\n", стр, ош)
+		сам.лог.Ошибка("уровеньОбновить(): строка уровня сбойная, стр=%q, ош=\n\t%v\n", стр, ош)
+		сам.вЛог.Добавить("ОШИБКА Арсенал.уровеньОбновить(): строка уровня сбойная, стр=%q, ош=\n\t%v\n", стр, ош)
 		return false
 	}
 	сам.уровень.Уст(иУровень)
-	сам.лог.Добавить("Арсенал.уровеньОбновить(): уровень=%d\n", иУровень)
+	сам.лог.Инфо("уровеньОбновить(): уровень=%d\n", иУровень)
+	сам.вЛог.Добавить("Арсенал.уровеньОбновить(): уровень=%d\n", иУровень)
 	return true
 }
 
 // Строит оружейку при нулевом уровне
 func (сам *Арсенал) построить() (bool, error) {
-	сам.лог.Добавить("Арсенал.построить()\n")
+	сам.вЛог.Добавить("Арсенал.построить()\n")
 	списСтр, ош := сам.сеть.ВебВоркер().Получ("http://wartank.ru/buildings")
 	if ош != nil {
-		сам.лог.Добавить("Арсенал.построить(): in make request, err=\n\t%v\n", ош)
+		сам.лог.Ошибка("построить(): при выполнении запроса, ош=\n\t%v\n", ош)
+		сам.вЛог.Добавить("Арсенал.построить(): при выполнении запроса, err=\n\t%v\n", ош)
 		return false, fmt.Errorf("")
 	}
 	// <span class="green2">Арсенал - 0</span><br/>
@@ -234,14 +238,15 @@ func (сам *Арсенал) построить() (bool, error) {
 		}
 	}
 	if !еслиНайти {
-		сам.лог.Добавить("Арсенал.построить(): не надо\n")
+		сам.вЛог.Добавить("Арсенал.построить(): не надо\n")
 		return true, nil
 	}
 	_стр := strings.TrimPrefix(стр, `<span class="green2">Арсенал - `)
 	_стр = strings.TrimSuffix(_стр, `</span><br/>`)
 	иУровень, ош := strconv.Atoi(_стр)
 	if ош != nil {
-		сам.лог.Добавить("ОШИБКА Арсенал.построить(): строка уровня сбойная, стр=%q, ош=\n\t%v\n", стр, ош)
+		сам.лог.Ошибка("построить(): строка уровня сбойная, стр=%q, ош=\n\t%v\n", стр, ош)
+		сам.вЛог.Добавить("ОШИБКА Арсенал.построить(): строка уровня сбойная, стр=%q, ош=\n\t%v\n", стр, ош)
 		return false, fmt.Errorf("")
 	}
 	сам.уровень.Уст(иУровень)
@@ -255,7 +260,7 @@ func (сам *Арсенал) построить() (bool, error) {
 		}
 	}
 	if !еслиНайти {
-		сам.лог.Добавить("Арсенал.построить(): не надо\n")
+		сам.вЛог.Добавить("Арсенал.построить(): не надо\n")
 		return true, nil
 	}
 	// Пробуем построить оружейку
@@ -264,7 +269,8 @@ func (сам *Арсенал) построить() (bool, error) {
 	ссылка := "https://wartank.ru/" + _стр
 	списСтр, ош = сам.сеть.ВебВоркер().Получ(ссылка)
 	if ош != nil {
-		сам.лог.Добавить("ОШИБКА Арсенал.построить(): при GET-команде 'построить оружейку', err=\n\t%v\n", ош)
+		сам.лог.Ошибка("построить(): при GET-команде 'построить оружейку', ош=\n\t%v\n", ош)
+		сам.вЛог.Добавить("ОШИБКА Арсенал.построить(): при GET-команде 'построить оружейку', err=\n\t%v\n", ош)
 		return false, fmt.Errorf("")
 	}
 	еслиНайти = false
@@ -276,7 +282,7 @@ func (сам *Арсенал) построить() (bool, error) {
 		}
 	}
 	if !еслиНайти {
-		сам.лог.Добавить("Арсенал.построить(): не надо\n")
+		сам.вЛог.Добавить("Арсенал.построить(): не надо\n")
 		return true, nil
 	}
 	_стр = strings.TrimPrefix(стр, "<a class=\"simple-but border mb5\" href=\"")
@@ -285,16 +291,18 @@ func (сам *Арсенал) построить() (bool, error) {
 	ссылка = "https://wartank.ru/building-upgrade/" + _стр
 	_, ош = сам.сеть.ВебВоркер().Получ(ссылка)
 	if ош != nil {
-		сам.лог.Добавить("ОШИБКА Арсенал.построить(): при GET-команде 'купить постройку оружейки', err=\n\t%v\n", ош)
+		сам.лог.Ошибка("построить(): при GET-команде 'купить постройку оружейки', ош=\n\t%v\n", ош)
+		сам.вЛог.Добавить("ОШИБКА Арсенал.построить(): при GET-команде 'купить постройку оружейки', err=\n\t%v\n", ош)
 		return false, fmt.Errorf("")
 	}
-	сам.лог.Добавить("Арсенал.построить(): ок\n")
+	сам.лог.Инфо("построить(): ок\n")
+	сам.вЛог.Добавить("Арсенал.построить(): ок\n")
 	return true, nil
 }
 
 // Пытается проапгрейдить оружейку
 func (сам *Арсенал) проапгрейдить() bool {
-	сам.лог.Добавить("Арсенал.проапгрейдить()\n")
+	сам.вЛог.Добавить("Арсенал.проапгрейдить()\n")
 	var (
 		еслиНайти = false
 		списСтр   []string
@@ -305,7 +313,7 @@ func (сам *Арсенал) проапгрейдить() bool {
 		defer time.Sleep(time.Millisecond * 1000)
 		списСтр, ош = сам.сеть.ВебВоркер().Получ("https://wartank.ru/building-upgrade/Armory")
 		if ош != nil {
-			сам.лог.Добавить("ОШИБКА Арсенал.проапгрейдить().фнКупить(): при GET-команде 'купить постройку оружейки', err=\n\t%v\n", ош)
+			сам.вЛог.Добавить("ОШИБКА Арсенал.проапгрейдить().фнКупить(): при GET-команде 'купить постройку оружейки', err=\n\t%v\n", ош)
 			return false
 		}
 		for _, стр = range списСтр {
@@ -316,7 +324,7 @@ func (сам *Арсенал) проапгрейдить() bool {
 			}
 		}
 		if !еслиНайти {
-			сам.лог.Добавить("Арсенал.проапгрейдить(): не надо\n")
+			сам.вЛог.Добавить("Арсенал.проапгрейдить(): не надо\n")
 			return true
 		}
 		// Пробуем улучшить шахту
@@ -327,7 +335,7 @@ func (сам *Арсенал) проапгрейдить() bool {
 		ссылка := "https://wartank.ru/building-upgrade/" + _стр
 		списСтр, ош = сам.сеть.ВебВоркер().Получ(ссылка)
 		if ош != nil {
-			сам.лог.Добавить("ОШИБКА Арсенал.проапгрейдить().фнКупить(): при GET-команде 'купить постройку оружейки', err=\n\t%v\n", ош)
+			сам.вЛог.Добавить("ОШИБКА Арсенал.проапгрейдить().фнКупить(): при GET-команде 'купить постройку оружейки', err=\n\t%v\n", ош)
 			return false
 		}
 		// Проверить, что постройка состоялась
@@ -337,7 +345,7 @@ func (сам *Арсенал) проапгрейдить() bool {
 				return false // Покупка не оплачена
 			}
 		}
-		сам.лог.Добавить("Арсенал.проапгрейдить().фнКупить(): ок\n")
+		сам.вЛог.Добавить("Арсенал.проапгрейдить().фнКупить(): ок\n")
 		return true
 	}
 
@@ -350,7 +358,7 @@ func (сам *Арсенал) проапгрейдить() bool {
 			}
 		}
 		if !еслиНайти {
-			сам.лог.Добавить("Арсенал.проапгрейдить().фнПодтверждение(): не надо\n")
+			сам.вЛог.Добавить("Арсенал.проапгрейдить().фнПодтверждение(): не надо\n")
 			return true
 		}
 		// Пробуем построить шахту
@@ -360,17 +368,17 @@ func (сам *Арсенал) проапгрейдить() bool {
 		ссылка := "https://wartank.ru" + _стр
 		списСтр, ош = сам.сеть.ВебВоркер().Получ(ссылка)
 		if ош != nil {
-			сам.лог.Добавить("ОШИБКА Арсенал.проапгрейдить().фнПодтверждение(): при GET-команде 'подтвердить постройку склада топлива', err=\n\t%v\n", ош)
+			сам.вЛог.Добавить("ОШИБКА Арсенал.проапгрейдить().фнПодтверждение(): при GET-команде 'подтвердить постройку склада топлива', err=\n\t%v\n", ош)
 			return false
 		}
 		// Проверить, что постройка состоялась
 		for _, стр := range списСтр {
 			if strings.Contains(стр, "<title>Вы сделали слишком большую паузу</title>") {
-				сам.лог.Добавить("ОШИБКА Арсенал.проапгрейдить().фнПодтверждение(): подтверждение покупка склада топлива не прошла\n\tlink=%v\n\tстр=\n\t%v\n", ссылка, стр)
+				сам.вЛог.Добавить("ОШИБКА Арсенал.проапгрейдить().фнПодтверждение(): подтверждение покупка склада топлива не прошла\n\tlink=%v\n\tстр=\n\t%v\n", ссылка, стр)
 				return false // Покупка не оплачена
 			}
 		}
-		сам.лог.Добавить("Арсенал.проапгрейдить().фнПодтверждение(): ок\n")
+		сам.вЛог.Добавить("Арсенал.проапгрейдить().фнПодтверждение(): ок\n")
 		return true
 	}
 
@@ -466,12 +474,8 @@ func (сам *Арсенал) Ремки() types.ИСтатПарам {
 
 // Обновляет состояние арсенала по требованию
 func (сам *Арсенал) СтатаОбновить() (err error) {
-	сам.лог.Добавить("Арсенал.СтатаОбновить()\n")
-	if ош := сам.сеть.Обновить(); ош != nil {
-		err := fmt.Errorf("ОШИБКА Арсенал.СтатаОбновить(): при обновлении lstArsenal, err=%w", ош)
-		сам.лог.Добавить("%v\n", err)
-		return err
-	}
+	сам.вЛог.Добавить("Арсенал.СтатаОбновить()\n")
+	сам.сеть.Обновить()
 	var (
 		strOut     string
 		lstArsenal = сам.СписПолучить()
@@ -490,7 +494,7 @@ func (сам *Арсенал) СтатаОбновить() (err error) {
 		iFugas, err := strconv.Atoi(strFugas)
 		if err != nil {
 			ош := fmt.Errorf("ОШИБКА Арсенал.СтатаОбновить(): fugas(%v) not number, err=\n\t%w", strFugas, err)
-			сам.лог.Добавить("%v\n", ош)
+			сам.вЛог.Добавить("%v\n", ош)
 			return ош
 		}
 		сам.Фугасы().Уст(iFugas)
@@ -509,11 +513,11 @@ func (сам *Арсенал) СтатаОбновить() (err error) {
 		iArmor, err := strconv.Atoi(strArmor)
 		if err != nil {
 			ош := fmt.Errorf("Арсенал.СтатаОбновить(): armor(%v) not number, err=\n\t%w", strArmor, err)
-			сам.лог.Добавить("%v\n", ош)
+			сам.вЛог.Добавить("%v\n", ош)
 			return ош
 		}
 		сам.Бронебойки().Уст(iArmor)
-		сам.лог.Добавить("Арсенал.СтатаОбновить(): бронебойки=%v\n", iArmor)
+		сам.вЛог.Добавить("Арсенал.СтатаОбновить(): бронебойки=%v\n", iArmor)
 	}
 	{ // Найти маркер кумулятивного снаряда
 		for _, strKumul := range lstArsenal {
@@ -554,11 +558,7 @@ func (сам *Арсенал) СтатаОбновить() (err error) {
 
 // Выбирает что надо делать, запускает процесс изготовления
 func (сам *Арсенал) сделать() bool {
-	ош := сам.сеть.Обновить()
-	if ош != nil {
-		// log._rintf("ERRO Арсенал.сделать(): при обновлении lstArsenal, err=\n\t%v\n", err)
-		return false
-	}
+	сам.сеть.Обновить()
 	// _mt.Println("\tArsenalNet.сделать()")
 	var (
 		ремкаКол  = сам.Ремки().Получ()
@@ -633,7 +633,7 @@ func (сам *Арсенал) сделатьБронебойки() bool {
 		// log._rintf("ERRO ArsenalNet.makeArmor(): in update lstArsenal,  err=\n\t%v\n", err)
 		return false
 	}
-	сам.СценаРежим().РежимУст(стрБронебойки)
+	сам.АренаСостояние().СостояниеУст(стрБронебойки)
 	return true
 }
 
@@ -668,7 +668,7 @@ func (сам *Арсенал) сделатьКумули() bool {
 		// log._rintf("ERRO ArsenalNet.makeKumul(): in make product arsenal kumul , err=\n\t%v\n", err)
 		return false
 	}
-	сам.СценаРежим().РежимУст(стрКумулятивы)
+	сам.АренаСостояние().СостояниеУст(стрКумулятивы)
 	return true
 }
 
@@ -704,7 +704,7 @@ func (сам *Арсенал) сделатьФугасы() bool {
 		// log._rintf("ERRO ArsenalNet.makeFugas(): in make request arsenal product, err=\n\t%v\n", err)
 		return false
 	}
-	сам.СценаРежим().РежимУст(стрФугасы)
+	сам.АренаСостояние().СостояниеУст(стрФугасы)
 	// log._rintf("INFO Арсенал.makeFugas()\n")
 	return true
 }
@@ -747,6 +747,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

@@ -1,31 +0,0 @@
-package arsenalnet
-
-import (
-	"fmt"
-
-	"wartank/pkg/components/scene_net"
-	"wartank/pkg/types"
-)
-
-/*
-	Планировщик боеприпасов и ремок для сети
-*/
-
-// ArsenalNet -- планировщик беоприпасов и ремок в сети
-type ArsenalNet struct {
-	*scene_net.СценаСеть
-}
-
-// НовАрсеналСеть -- возвращает новый *ArsenalNet
-func НовАрсеналСеть(arsenal types.ИАрсенал) (*ArsenalNet, error) {
-	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)
-	}
-
-	сам := &ArsenalNet{
-		СценаСеть: sectionNet,
-	}
-
-	return сам, nil
-}

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

@@ -6,12 +6,11 @@ import (
 	"strconv"
 	"strings"
 	"time"
-
 	"wartank/pkg/alias"
-	"wartank/pkg/section"
+	"wartank/pkg/arena"
+	"wartank/pkg/components/arena_net"
 	"wartank/pkg/types"
 	"wartank/server/serv_bots/warbot/angar/base/bank/bankmode"
-	"wartank/server/serv_bots/warbot/angar/base/bank/banknet"
 	"wartank/server/serv_bots/warbot/tank_stat/static_param"
 )
 
@@ -21,8 +20,8 @@ import (
 
 // Банк -- объект банка на базе
 type Банк struct {
-	*section.Секция
-	сеть       *banknet.BankNet
+	types.ИАрена
+	сеть       types.ИАренаСеть
 	сереброБот types.ИСтатПарам
 	режим1     *bankmode.BankMode // 1 режим работы на выбор
 	режим2     *bankmode.BankMode // 2 режим работы на выбор
@@ -30,25 +29,19 @@ type Банк struct {
 
 // НовБанк -- возвращает новый *Bank
 func НовБанк(база types.ИБаза) (*Банк, error) {
-	section, ош := section.НовСекция(база.Бот(), "Банк", `<span class="green2">Серебро</span><br/>`)
-	if ош != nil {
-		return nil, fmt.Errorf("НовБанк(): при создании секции банка, ош=\n\t%w", ош)
-	}
+	арена := arena.НовАрена(база.Бот(), "Банк", `<span class="green2">Серебро</span><br/>`)
 	сереброБот, ош := static_param.НовСтатПарам("silver_bot")
 	if ош != nil {
 		return nil, fmt.Errorf("НовБанк(): при создании статы серебра бота, ош=\n\t%w", ош)
 	}
 
 	сам := &Банк{
-		Секция:     section,
+		ИАрена:     арена,
 		сереброБот: сереброБот,
 		режим1:     bankmode.NewBankMode(),
 		режим2:     bankmode.NewBankMode(),
 	}
-	сам.сеть, ош = banknet.NewBankNet(сам)
-	if ош != nil {
-		return nil, fmt.Errorf("NewBank(): in create NetBank, err=\n\t%w", ош)
-	}
+	сам.сеть = arena_net.НовАренаСеть(сам, "https://wartank.ru/production/Bank")
 	return сам, nil
 }
 
@@ -61,9 +54,7 @@ func (сам *Банк) Пуск() error {
 
 // UpdateLst -- принудительно обновляет состояние банка
 func (сам *Банк) UpdateLst() {
-	if err := сам.сеть.Обновить(); err != nil {
-		log.Printf("Банк.UpdateLst(): err=\n\t%v\n", err)
-	}
+	сам.сеть.Обновить()
 }
 
 // запускает банк в опрос
@@ -80,10 +71,7 @@ func (сам *Банк) пуск() {
 			time.Sleep(time.Minute * 25)
 			return
 		}
-		if ош := сам.сеть.Обновить(); ош != nil {
-			// log._rintf("ERRO Банк.пуск():  при обновлении lstBank, err=\n\t%v\n", err)
-			return
-		}
+		сам.сеть.Обновить()
 
 		if ош := сам.получитьВсеРежимы(); ош != nil {
 			log.Printf("ERRO Банк.пуск(): при получении списка режимов банка, err=\n\t%v\n", ош)
@@ -302,7 +290,7 @@ func (сам *Банк) сделатьСеребро() (alias.МилСек, erro
 		if err = сам.СтрОбновить(lstBank); err != nil {
 			return 0, fmt.Errorf("BankNet.makeProduct(): при обновлении lstBank, err=%w", err)
 		}
-		if err := сам.Уст(alias.Время(time1)); err != nil {
+		if err := сам.ОбратВремяУст(alias.Время(time1)); err != nil {
 			log.Printf("WARN Банк.makeProduct(): при установке времени производства банка(%v)\n\terr=%v\n", time1, err)
 		}
 	}

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

@@ -1,33 +0,0 @@
-package banknet
-
-import (
-	"fmt"
-	"log"
-
-	"wartank/pkg/components/scene_net"
-	"wartank/pkg/types"
-)
-
-/*
-	Автоматически опрашивает банк, собирает ресурсы, отдаёт задачу на опрос банка.
-*/
-
-// BankNet -- обзор базы
-type BankNet struct {
-	*scene_net.СценаСеть
-}
-
-// NewBankNet -- возвращает новый *BankNet
-func NewBankNet(bank types.ИБанк) (*BankNet, error) {
-	log.Printf("NewBankNet()\n")
-	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)
-	}
-
-	сам := &BankNet{
-		СценаСеть: sectionNet,
-	}
-
-	return сам, nil
-}

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

@@ -1,3 +1,4 @@
+// package base -- база в игре
 package base
 
 import (
@@ -7,14 +8,13 @@ import (
 	"strings"
 	"sync"
 	"time"
-
 	"wartank/pkg/alias"
+	"wartank/pkg/arena"
+	"wartank/pkg/components/arena_net"
 	"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"
-	"wartank/server/serv_bots/warbot/angar/base/basenet"
 	"wartank/server/serv_bots/warbot/angar/base/fuel"
 	"wartank/server/serv_bots/warbot/angar/base/labor"
 	"wartank/server/serv_bots/warbot/angar/base/market"
@@ -34,9 +34,9 @@ const (
 
 // База -- объект базы
 type База struct {
-	*section.Секция
+	types.ИАрена
 	бот          types.ИБот
-	сеть         *basenet.BaseNet
+	сеть         types.ИАренаСеть
 	арсенал      types.ИАрсенал
 	банк         *bank.Банк
 	полигон      *polygon.Полигон
@@ -50,21 +50,15 @@ type База struct {
 
 // НовБаза -- возвращает новую базу бота
 func НовБаза(ангар types.ИАнгар) (*База, error) {
-	section, ош := section.НовСекция(ангар.Бот(), "База", `<title>База</title>`)
-	if ош != nil {
-		return nil, fmt.Errorf("НовБаза(): in create ISection, err=\n\t%w", ош)
-	}
-	log.Printf("НовБаза(): %q\n", section.Бот().Имя())
+	арена := arena.НовАрена(ангар.Бот(), "База", `<title>База</title>`)
+	log.Printf("НовБаза(): %q\n", арена.Бот().Имя())
 	сам := &База{
-		Секция: section,
+		ИАрена: арена,
 		бот:    ангар.Бот(),
 	}
-	{ // База в сети
-		сам.сеть, ош = basenet.NewBaseNet(сам)
-		if ош != nil {
-			return nil, fmt.Errorf("NewBase(): in create NetBase, err=\n\t%w", ош)
-		}
-	}
+	strUrl := "https://wartank.ru/buildings"
+	сам.сеть = arena_net.НовАренаСеть(сам, strUrl)
+	var ош error
 	{ // Arsenal
 		сам.арсенал, ош = arsenal.НовАрсенал(сам)
 		if ош != nil {
@@ -124,9 +118,7 @@ func (сам *База) Пуск() error {
 func (сам *База) пуск() {
 	фнЦикл := func() {
 		defer time.Sleep(time.Minute * 2)
-		if ош := сам.сеть.Обновить(); ош != nil { // Обновить состояние базы
-			log.Printf("ERRO Base.Run(): при обновлении базы, err=\n\t%v\n", ош)
-		}
+		сам.сеть.Обновить()
 		сам.проверитьПолигонУсиление()              // Проверить усиление полигона
 		if err := сам.проверитьБанк(); err != nil { // Проверка режимов банка
 			log.Printf("ERRO Base.Run(): при проверке банка, err=\n\t%v\n", err)
@@ -189,7 +181,7 @@ func (сам *База) setCountDown() {
 	if timeCount > "00:10:00" {
 		сам.времОстат = 600
 	}
-	ош := сам.Секция.ОбратВремяУст(alias.Время(timeCount))
+	ош := сам.ОбратВремяУст(alias.Время(timeCount))
 	if ош != nil {
 		log.Printf("ERRO Base.setCountDown(): при установке обратного отсчёта времени, err=\n\t%v\n", ош)
 		сам.Отмена()
@@ -229,7 +221,7 @@ func (сам *База) проверитьШахту() {
 		сам.шахтаСтатаОбновить()
 	}
 	сам.шахтаАпгрейдФорсаж() // Нужно ли ускорить апгрейд шахты
-	if сам.шахта.СценаРежим().Режим() == "upgrade" {
+	if сам.шахта.АренаСостояние().Состояние() == "upgrade" {
 		return
 	}
 	сам.шахтаСтатаОбновить()
@@ -394,22 +386,22 @@ func (сам *База) шахтаСтатаОбновить() {
 			strNum := lstNum[1]
 			lstNum = strings.Split(strNum, `</div></td>`)
 			strNum = lstNum[0]
-			работа := alias.СценаРабота("Железо-" + strNum)
-			сам.шахта.СценаРежим().РаботаУст(работа)
+			работа := alias.АренаРаботаИмя("Железо-" + strNum)
+			сам.шахта.АренаСостояние().РаботаИмяУст(работа)
 		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]
-			работа := alias.СценаРабота("Руда-" + strNum)
-			сам.шахта.СценаРежим().РаботаУст(работа)
+			работа := alias.АренаРаботаИмя("Руда-" + strNum)
+			сам.шахта.АренаСостояние().РаботаИмяУст(работа)
 		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]
-			работа := alias.СценаРабота("Сталь-" + strNum)
-			сам.шахта.СценаРежим().РаботаУст(работа)
+			работа := alias.АренаРаботаИмя("Сталь-" + strNum)
+			сам.шахта.АренаСостояние().РаботаИмяУст(работа)
 		}
 	}
 }
@@ -426,11 +418,11 @@ func (сам *База) проверитьАрсенал() {
 			return
 		}
 	*/
-	if работа := сам.арсенал.СценаРежим().Работа(); работа == "" {
+	if работа := сам.арсенал.АренаСостояние().РаботаИмя(); работа == "" {
 		сам.проверитьАрсеналРежим()
 	}
 	сам.проверитьАрсеналУскорение() // Нужно ли ускорить апгрейд арсенала
-	if сам.арсенал.СценаРежим().Режим() == cons.РежимАпгрейд {
+	if сам.арсенал.АренаСостояние().Состояние() == cons.РежимАпгрейд {
 		return
 	}
 	сам.проверитьАрсеналВремя()
@@ -482,19 +474,19 @@ func (сам *База) проверитьАрсеналРежим() {
 	)
 	for _, strOut = range lstBase {
 		if strings.Contains(strOut, `HollowCharge.png`) {
-			сам.арсенал.СценаРежим().РежимУст("кумулятивы")
+			сам.арсенал.АренаСостояние().СостояниеУст("кумулятивы")
 			return
 		}
 		if strings.Contains(strOut, `ArmorPiercing.png`) {
-			сам.арсенал.СценаРежим().РежимУст("бронебойки")
+			сам.арсенал.АренаСостояние().СостояниеУст("бронебойки")
 			return
 		}
 		if strings.Contains(strOut, `HighExplosive.png`) {
-			сам.арсенал.СценаРежим().РежимУст("фугасы")
+			сам.арсенал.АренаСостояние().СостояниеУст("фугасы")
 			return
 		}
 		if strings.Contains(strOut, `repairkit.gif`) {
-			сам.арсенал.СценаРежим().РежимУст("ремки")
+			сам.арсенал.АренаСостояние().СостояниеУст("ремки")
 			return
 		}
 	}
@@ -528,8 +520,8 @@ func (сам *База) проверитьАрсеналУскорение() {
 						log.Printf("WARN Base.checkArsenalForce(): при установке платного времени ускорения апгрейда арсенала(%v)\n\terr=%v\n", времОжидПлат, err)
 					}
 				*/
-				сам.арсенал.СценаРежим().РаботаУст("апгрейд")
-				сам.арсенал.СценаРежим().РежимУст(cons.РежимАпгрейд)
+				сам.арсенал.АренаСостояние().СостояниеУст("апгрейд")
+				сам.арсенал.АренаСостояние().СостояниеУст(cons.РежимАпгрейд)
 				return
 			}
 		}
@@ -551,7 +543,7 @@ func (сам *База) проверитьАрсеналУскорение() {
 		if !strings.Contains(strOut, `>Ускорение<`) {
 			return
 		}
-		сам.арсенал.СценаРежим().РежимУст(cons.РежимАпгрейд)
+		сам.арсенал.АренаСостояние().СостояниеУст(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>`)
@@ -566,8 +558,8 @@ func (сам *База) проверитьАрсеналУскорение() {
 			// log._rintf("ERRO NetBank.checkArsenalForce(): при обновлении lstBase, err=\n\t%v\n", err)
 			return
 		}
-		сам.арсенал.СценаРежим().РаботаУст("апгрейд")
-		сам.арсенал.СценаРежим().РежимУст(cons.РежимАпгрейд)
+		сам.арсенал.АренаСостояние().СостояниеУст("апгрейд")
+		сам.арсенал.АренаСостояние().СостояниеУст(cons.РежимАпгрейд)
 		/*
 			if err := сам.арсенал.ОбратВремяУст(времОжидБесплат); err != nil {
 				log.Printf("WARN Base.checkArsenalForce(): при установке бесплатного времени ускорения апгрейда арсенала(%v)\n\terr=%v\n", времОжидБесплат, err)
@@ -575,12 +567,12 @@ func (сам *База) проверитьАрсеналУскорение() {
 		*/
 	}
 	// Все проверки прошли -- это просто работа
-	сам.арсенал.СценаРежим().РежимУст(cons.РежимРабота)
+	сам.арсенал.АренаСостояние().СостояниеУст(cons.РежимРабота)
 }
 
 // Проверяет режим банка
 func (сам *База) проверитьБанк() error {
-	if сам.банк.СценаРежим().Работа() == "" {
+	if сам.банк.АренаСостояние().РаботаИмя() == "" {
 		сам.checkBankMode()
 	}
 	сам.checkBankTime() // Проверка времени ожидания
@@ -589,7 +581,7 @@ func (сам *База) проверитьБанк() error {
 		return nil
 	}
 	сам.checkBankForce() // Нужно ли ускорить апгрейд банка
-	if сам.банк.СценаРежим().Режим() == cons.РежимАпгрейд {
+	if сам.банк.АренаСостояние().Состояние() == cons.РежимАпгрейд {
 		return nil
 	}
 	сам.checkBankProduct() // Запуск производства в  банке
@@ -615,9 +607,9 @@ func (сам *База) 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>`)
-	работа := alias.СценаРабота("Серебро-" + lstSilver[0])
-	сам.банк.СценаРежим().РаботаУст(работа)
-	сам.банк.СценаРежим().РежимУст(cons.РежимРабота)
+	работа := alias.АренаРаботаИмя("Серебро-" + lstSilver[0])
+	сам.банк.АренаСостояние().РаботаИмяУст(работа)
+	сам.банк.АренаСостояние().СостояниеУст(cons.РежимРабота)
 
 }
 
@@ -647,7 +639,7 @@ func (сам *База) checkBankTime() {
 	strTime := lstTime[1]
 	lstTime = strings.Split(strTime, `</span></span></div></td>`)
 	strTime = lstTime[0]
-	if err := сам.банк.Уст(alias.Время(strTime)); err != nil {
+	if err := сам.банк.ОбратВремяУст(alias.Время(strTime)); err != nil {
 		log.Printf("ERRO Base.checkBankTime(): при установке времени ожидания банка(%v)\n\terr=%v\n", strTime, err)
 	}
 }
@@ -706,8 +698,8 @@ func (сам *База) checkBankForce() {
 			if err := сам.банк.ОбратВремяУст(времОжидПлат); err != nil {
 				log.Printf("WARN Base.checkBankForce(): при установке времени ожидания платного ускорения апгрейда банка(%v)\n\terr=%v\n", времОжидПлат, err)
 			}
-			сам.банк.СценаРежим().РаботаУст("апгрейд")
-			сам.банк.СценаРежим().РежимУст(cons.РежимАпгрейд)
+			сам.банк.АренаСостояние().РаботаИмяУст("")
+			сам.банк.АренаСостояние().СостояниеУст(cons.РежимАпгрейд)
 			return
 		}
 	}
@@ -737,8 +729,8 @@ func (сам *База) checkBankForce() {
 				// log._rintf("ERRO NetBank.checkBankForce(): при обновлении lstBase, err=\n\t%v\n", err)
 				return
 			}
-			сам.банк.СценаРежим().РаботаУст("апгрейд")
-			сам.банк.СценаРежим().РежимУст(cons.РежимАпгрейд)
+			сам.банк.АренаСостояние().РаботаИмяУст("")
+			сам.банк.АренаСостояние().СостояниеУст(cons.РежимАпгрейд)
 			if err := сам.банк.ОбратВремяУст(времОжидБесплат); err != nil {
 				log.Printf("WARN Base.checkBankForce(): при установке времени бесплатного ускорения агрейда банка(%v)\n\terr=%v\n", времОжидБесплат, err)
 			}
@@ -765,8 +757,8 @@ func (сам *База) шахтаАпгрейдФорсаж() {
 			}
 		}
 		if isOut && strings.Contains(strOut, `Ускорить за`) {
-			сам.шахта.СценаРежим().РаботаУст("апгрейд")
-			сам.шахта.СценаРежим().РежимУст(cons.РежимАпгрейд)
+			сам.шахта.АренаСостояние().РаботаИмяУст("")
+			сам.шахта.АренаСостояние().СостояниеУст(cons.РежимАпгрейд)
 			/*
 				if err := сам.шахта.ОбратВремяУст(времОжидПлат); err != nil {
 					log.Printf("WARN Base.checkMineForce(): при установке времени платного апгрейда шахты(%v)\n\terr=%v\n", времОжидПлат, err)
@@ -806,13 +798,13 @@ func (сам *База) шахтаАпгрейдФорсаж() {
 				}
 			*/
 			// sound.MineForce()
-			сам.шахта.СценаРежим().РаботаУст("апгрейд")
-			сам.шахта.СценаРежим().РежимУст(cons.РежимАпгрейд)
+			сам.шахта.АренаСостояние().РаботаИмяУст("")
+			сам.шахта.АренаСостояние().СостояниеУст(cons.РежимАпгрейд)
 			return
 		}
 	}
 	// Все проверки прошли -- это просто работа
-	сам.шахта.СценаРежим().РежимУст(cons.РежимРабота)
+	сам.шахта.АренаСостояние().СостояниеУст(cons.РежимРабота)
 }
 
 // Проверяет на ускорение апгрейда полигона
@@ -846,8 +838,8 @@ func (сам *База) проверитьПолигонУсиление() {
 			// if err := сам.polygon.CountDown().Set(strTime); err != nil {
 			// 	// log._rintf("WARN Base.checkMineForce(): при установке времени апгрейда полигона(%v)\n\terr=%v\n", strTime, err)
 			// }
-			сам.полигон.СценаРежим().РаботаУст("апгрейд")
-			сам.полигон.СценаРежим().РежимУст(cons.РежимАпгрейд)
+			сам.полигон.АренаСостояние().РаботаИмяУст("")
+			сам.полигон.АренаСостояние().СостояниеУст(cons.РежимАпгрейд)
 			if err := сам.полигон.ОбратВремяУст(времОжидПлат); err != nil {
 				log.Printf("WARN Base.checkPolygonForce(): при установке платного времени апгрейда полигона(%v)\n\terr=%v\n", времОжидПлат, err)
 			}
@@ -880,8 +872,8 @@ func (сам *База) проверитьПолигонУсиление() {
 				return
 			}
 			// sound.MineForce()
-			сам.полигон.СценаРежим().РаботаУст("апгрейд")
-			сам.полигон.СценаРежим().РежимУст(cons.РежимАпгрейд)
+			сам.полигон.АренаСостояние().РаботаИмяУст("")
+			сам.полигон.АренаСостояние().СостояниеУст(cons.РежимАпгрейд)
 			// Установить время ожидания для обновления
 			if err := сам.полигон.ОбратВремяУст(времОжидБесплат); err != nil {
 				log.Printf("WARN Base.checkPolygonForce(): при установке времени бесплатного апгрейда полигона(%v)\n\terr=%v\n", времОжидБесплат, err)
@@ -891,5 +883,5 @@ func (сам *База) проверитьПолигонУсиление() {
 		}
 	}
 	// Все проверки прошли -- это просто работа
-	сам.полигон.СценаРежим().РежимУст(cons.РежимРабота)
+	сам.полигон.АренаСостояние().СостояниеУст(cons.РежимРабота)
 }

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

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

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

@@ -8,17 +8,16 @@ import (
 	"strconv"
 	"strings"
 	"time"
-
-	"wartank/pkg/section"
+	"wartank/pkg/arena"
+	"wartank/pkg/components/arena_net"
 	"wartank/pkg/types"
-	"wartank/server/serv_bots/warbot/angar/base/fuel/fuel_net"
 	"wartank/server/serv_bots/warbot/tank_stat/static_param"
 )
 
 // СкладТоплива -- склад топлива
 type СкладТоплива struct {
-	*section.Секция
-	сеть         *fuel_net.ТопливоСеть
+	types.ИАрена
+	сеть         types.ИАренаСеть
 	бот          types.ИБот
 	база         types.ИБаза
 	топливо      types.ИСтатПарам
@@ -30,10 +29,7 @@ type СкладТоплива struct {
 
 // НовТопливо -- возвращает новой склад топлива
 func НовСкладТоплива(база types.ИБаза) (*СкладТоплива, error) {
-	секция, ош := section.НовСекция(база.Бот(), "Склад_топлива", `<span class="green2">Склад топлива - `)
-	if ош != nil {
-		return nil, fmt.Errorf("НовСкладТоплива(): in create *Section, err=\n\t%w", ош)
-	}
+	секция := arena.НовАрена(база.Бот(), "Склад_топлива", `<span class="green2">Склад топлива - `)
 	топливо, ош := static_param.НовСтатПарам("топливо")
 	if ош != nil {
 		return nil, fmt.Errorf("НовСкладТоплива(): при создании статистики склаада топлива, ош=\n\t%w", ош)
@@ -44,7 +40,7 @@ func НовСкладТоплива(база types.ИБаза) (*СкладТо
 	}
 	кнт, фнОтмена := context.WithCancel(база.Контекст())
 	сам := &СкладТоплива{
-		Секция:   секция,
+		ИАрена:   секция,
 		бот:      база.Бот(),
 		база:     база,
 		топливо:  топливо,
@@ -53,10 +49,7 @@ func НовСкладТоплива(база types.ИБаза) (*СкладТо
 		уровень:  уровень,
 	}
 
-	сам.сеть, ош = fuel_net.НовТопливоСеть(сам)
-	if ош != nil {
-		return nil, fmt.Errorf("NewMine(): in create *ТопливоСеть, err=\n\t%w", ош)
-	}
+	сам.сеть = arena_net.НовАренаСеть(сам, "https://wartank.ru/fuelStore")
 	_ = types.ИБазаТопливо(сам)
 	return сам, nil
 }

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

@@ -1,25 +0,0 @@
-// package fuel_net -- склад топлива
-package fuel_net
-
-import (
-	"fmt"
-	"wartank/pkg/components/scene_net"
-	"wartank/pkg/types"
-)
-
-// ТопливоСеть -- опрашивает склад топлива на базе
-type ТопливоСеть struct {
-	*scene_net.СценаСеть
-}
-
-// НовТопливоСеть -- возвращает новый склад топлива
-func НовТопливоСеть(складТоплива types.ИБазаТопливо) (*ТопливоСеть, error) {
-	sectionNet, err := scene_net.НовСекцияСеть(складТоплива, "https://wartank.ru/fuelStore")
-	if err != nil {
-		return nil, fmt.Errorf("НовТопливоСеть(): при создании *Топливо сеть, ош=\n\t%w", err)
-	}
-	сам := &ТопливоСеть{
-		СценаСеть: sectionNet,
-	}
-	return сам, nil
-}

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

@@ -8,41 +8,33 @@ import (
 	"strings"
 	"time"
 	"wartank/pkg/alias"
-	"wartank/pkg/section"
+	"wartank/pkg/arena"
+	"wartank/pkg/components/arena_net"
 	"wartank/pkg/types"
-	"wartank/server/serv_bots/warbot/angar/base/market/marketnet"
 	"wartank/server/serv_bots/warbot/tank_stat/static_param"
 )
 
 // Рынок -- объект рынка
 type Рынок struct {
-	*section.Секция
+	types.ИАрена
 	бот     types.ИБот
-	сеть    *marketnet.MarketNet
+	сеть    types.ИАренаСеть
 	уровень types.ИСтатПарам
 }
 
 // НовРынок -- возвращает новый рынок
 func НовРынок(база types.ИБаза) (*Рынок, error) {
-	section, err := section.НовСекция(база.Бот(), "Рынок", `<title>Рынок</title>`)
-	if err != nil {
-		return nil, fmt.Errorf("NewMarket(): in create *Section, err=\n\t%w", err)
-	}
+	арена := arena.НовАрена(база.Бот(), "Рынок", `<title>Рынок</title>`)
 	уровень, ош := static_param.НовСтатПарам("уровень")
 	if ош != nil {
 		return nil, fmt.Errorf("НовРынок(): при создании статистики уровня, ош=\n\t%w", ош)
 	}
 	сам := &Рынок{
-		Секция:  section,
+		ИАрена:  арена,
 		бот:     база.Бот(),
 		уровень: уровень,
 	}
-	{ // Маркет
-		сам.сеть, err = marketnet.NewMarketNet(сам)
-		if err != nil {
-			return nil, fmt.Errorf("NewMarket(): in create NetMarket, err=\n\t%w", err)
-		}
-	}
+	сам.сеть = arena_net.НовАренаСеть(сам, "https://wartank.ru/market")
 	return сам, nil
 }
 
@@ -341,10 +333,7 @@ func (сам *Рынок) проверОжидание() {
 	)
 	// countDown := сам.CountDown().Get()
 	фнЕслиСеребро := func() bool { // Найти счётчик цены серебра
-		if ош := сам.сеть.Обновить(); ош != nil { // Принудительное ПЕРВОЕ обновление рынка
-			log.Printf("Market.checkTime(): при обновлении lstMarket, err=\n\t%v\n", ош)
-			return false
-		}
+		сам.сеть.Обновить()
 		еслиНайдено := false
 		lstMarket := сам.СписПолучить()
 		for _, strOut = range lstMarket {
@@ -384,7 +373,7 @@ func (сам *Рынок) проверОжидание() {
 		}
 		lstTime := strings.Split(strOut, `Минимальная цена через `)
 		strTime := lstTime[1]
-		if err := сам.Уст(alias.Время(strTime)); err != nil {
+		if err := сам.ОбратВремяУст(alias.Время(strTime)); err != nil {
 			// log._rintf("ERRO Market.checkTime(): при установке времени ожидания рынка(%v)\n\terr=%v\n", strTime, err)
 			return // Возможно минимальная цена
 		}

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

@@ -1,31 +0,0 @@
-package marketnet
-
-import (
-	"fmt"
-
-	"wartank/pkg/components/scene_net"
-	"wartank/pkg/types"
-)
-
-/*
-	Автоматически опрашивает рынок, покупает золотишко.
-*/
-
-// MarketNet -- обзор рынка
-type MarketNet struct {
-	*scene_net.СценаСеть
-}
-
-// NewMarketNet -- возвращает новый *MarketNet
-func NewMarketNet(market types.ИРынок) (*MarketNet, error) {
-	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)
-	}
-
-	сам := &MarketNet{
-		СценаСеть: sectionNet,
-	}
-
-	return сам, nil
-}

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

@@ -7,18 +7,17 @@ import (
 	"strconv"
 	"strings"
 	"time"
-
 	"wartank/pkg/alias"
-	"wartank/pkg/section"
+	"wartank/pkg/arena"
+	"wartank/pkg/components/arena_net"
 	"wartank/pkg/types"
-	"wartank/server/serv_bots/warbot/angar/base/mine/minenet"
 	"wartank/server/serv_bots/warbot/tank_stat/static_param"
 )
 
 // Шахта -- объект шахты на базе
 type Шахта struct {
-	*section.Секция
-	сеть         *minenet.MineNet
+	types.ИАрена
+	сеть         types.ИАренаСеть
 	лог          types.ИВебЛог
 	бот          types.ИБот
 	база         types.ИБаза
@@ -36,10 +35,7 @@ type Шахта struct {
 
 // НовШахта -- возвращает новый *Mine
 func НовШахта(база types.ИБаза) (types.ИБазаШахта, error) {
-	секция, ош := section.НовСекция(база.Бот(), "Шахта", `<span class="green2">Руда</span><br/>`)
-	if ош != nil {
-		return nil, fmt.Errorf("НовШахта(): in create *Section, err=\n\t%w", ош)
-	}
+	арена := arena.НовАрена(база.Бот(), "Шахта", `<span class="green2">Руда</span><br/>`)
 	руда, ош := static_param.НовСтатПарам("руда")
 	if ош != nil {
 		return nil, fmt.Errorf("НовШахта(): при создании статистики руды, ош=\n\t%w", ош)
@@ -66,7 +62,7 @@ func НовШахта(база types.ИБаза) (types.ИБазаШахта, er
 	}
 	кнт, фнОтмена := context.WithCancel(база.Контекст())
 	сам := &Шахта{
-		Секция:     секция,
+		ИАрена:     арена,
 		бот:        база.Бот(),
 		база:       база,
 		руда:       руда,
@@ -77,13 +73,10 @@ func НовШахта(база types.ИБаза) (types.ИБазаШахта, er
 		уровень:    уровень,
 		кнт:        кнт,
 		фнОтмена:   фнОтмена,
-		лог:        секция.Лог(),
+		лог:        арена.ВебЛог(),
 	}
 
-	сам.сеть, ош = minenet.NewMineNet(сам)
-	if ош != nil {
-		return nil, fmt.Errorf("NewMine(): in create NetMine, err=\n\t%w", ош)
-	}
+	сам.сеть = arena_net.НовАренаСеть(сам, "https://wartank.ru/production/Mine")
 	go сам.пуск()
 	сам.лог.ОтклВывод()
 	сам.лог.Добавить("Шахта.НовШахта(): бот=%q\n", сам.бот.Имя())
@@ -266,7 +259,7 @@ func (сам *Шахта) количествоПолучить() (bool, error) {
 	strTime = strings.TrimPrefix(strTime, `<td><div class="value-block lh1"><span><span>`)
 	strTime = strings.TrimSuffix(strTime, `</span></span></div></td>`)
 	сам.продуктВремя = strTime
-	if err := сам.Уст(alias.Время(strTime)); err != nil {
+	if err := сам.ОбратВремяУст(alias.Время(strTime)); err != nil {
 		сам.лог.Добавить("ОШИБКА Шахта.количествоПолучить(): при установке времени производства(%v), err=\n\t%v\n", strTime, err)
 	}
 	сам.лог.Добавить("Шахта.количествоПолучить(): время=%q\n", strTime)
@@ -540,15 +533,12 @@ func (сам *Шахта) проапгрейдить() bool {
 
 // Сделать -- вызывается с базы, если она обнаружила, что пора сделать продукцию
 func (сам *Шахта) Сделать() {
-	if ош := сам.сеть.Обновить(); ош != nil {
-		сам.лог.Добавить("ERRO Шахта.Сделать(): при обновлении lstMine, err=\n\t%v\n", ош)
-		return
-	}
+	сам.сеть.Обновить()
 	if err := сам.выбратьМеталл(); err != nil {
 		сам.лог.Добавить("ERRO Шахта.Сделать(): при выборе продукции, err=\n\t%v\n", err)
 		return
 	}
-	работа := сам.СценаРежим().Работа()
+	работа := сам.АренаСостояние().РаботаИмя()
 	switch работа {
 	case "руда":
 		for !сам.рудаСделать() {
@@ -642,26 +632,26 @@ func (сам *Шахта) выбратьМеталл() error {
 		}
 	}
 	фнВыбратьПродукт()
-	сам.СценаРежим().РаботаУст("руда")
+	сам.АренаСостояние().РаботаИмяУст("руда")
 	руда := сам.Руда().Получ()
 	железо := сам.Железо().Получ()
 	if диктПродукция["железо"] {
 		if руда > железо*2 {
-			сам.СценаРежим().РаботаУст("железо")
+			сам.АренаСостояние().РаботаИмяУст("железо")
 		}
 	}
 
 	сталь := сам.Сталь().Получ()
 	if диктПродукция["сталь"] {
 		if железо > сталь*2 {
-			сам.СценаРежим().РаботаУст("сталь")
+			сам.АренаСостояние().РаботаИмяУст("сталь")
 		}
 	}
 
 	свинец := сам.Свинец().Получ()
 	if диктПродукция["свинец"] {
 		if сталь > свинец*2 {
-			сам.СценаРежим().РаботаУст("свинец")
+			сам.АренаСостояние().РаботаИмяУст("свинец")
 		}
 	}
 
@@ -720,7 +710,7 @@ func (сам *Шахта) рудаСделать() bool {
 		// log._rintf("ERRO Шахта.сделатьРуду(): при обновлении lstMine, err=\n\t%v\n", err)
 		return false
 	}
-	if err := сам.Уст(alias.Время(strTime)); err != nil {
+	if err := сам.ОбратВремяУст(alias.Время(strTime)); err != nil {
 		сам.лог.Добавить("ERRO Шахта.сделатьРуду(): при установке времени ожидания добычи руды(%v)\n\terr=%v\n", strTime, err)
 	}
 	lstNum := strings.Split(strNum, `Кол-во: <span class="green2">`)
@@ -782,7 +772,7 @@ func (сам *Шахта) железоСделать() bool {
 		// log._rintf("ERRO MineNet.makeFerrum(): при обновлении lstMine, err=\n\t%v\n", err)
 		return false
 	}
-	if err := сам.Уст(alias.Время(strTime)); err != nil {
+	if err := сам.ОбратВремяУст(alias.Время(strTime)); err != nil {
 		сам.лог.Добавить("ERRO Mine.makeFerrum(): при установке времени производства железа(%v)\n\terr=%v\n", strTime, err)
 	}
 	lstNum := strings.Split(strNum, `Кол-во: <span class="green2">`)
@@ -841,7 +831,7 @@ func (сам *Шахта) стальСделать() bool {
 		// log._rintf("ERRO MineNet.makeSteel(): при обновлении lstMine, err=\n\t%v\n", err)
 		return false
 	}
-	if err := сам.Уст(alias.Время(strTime)); err != nil {
+	if err := сам.ОбратВремяУст(alias.Время(strTime)); err != nil {
 		сам.лог.Добавить("ERRO Mine.makeSteel(): при установке времени производства железа(%v)\n\terr=%v\n", strTime, err)
 	}
 	lstNum := strings.Split(strNum, `Кол-во: <span class="green2">`)
@@ -900,7 +890,7 @@ func (сам *Шахта) свинецСделать() bool {
 		// log._rintf("ERRO Шахта.сделатьСвинец(): при обновлении lstMine, err=\n\t%v\n", err)
 		return false
 	}
-	if err := сам.Уст(alias.Время(strTime)); err != nil {
+	if err := сам.ОбратВремяУст(alias.Время(strTime)); err != nil {
 		сам.лог.Добавить("ERRO Шахта.сделатьСвинец(): при установке времени производства железа(%v)\n\terr=%v\n", strTime, err)
 	}
 	lstNum := strings.Split(strNum, `Кол-во: <span class="green2">`)

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

@@ -1,28 +0,0 @@
-package minenet
-
-import (
-	"fmt"
-	"wartank/pkg/components/scene_net"
-	"wartank/pkg/types"
-)
-
-/*
-	Опрашивает шахту в сети
-*/
-
-// MineNet -- опрашивает шахту на базе
-type MineNet struct {
-	*scene_net.СценаСеть
-}
-
-// NewMineNet -- возвращает новый *MineNet
-func NewMineNet(mine types.ИБазаШахта) (*MineNet, error) {
-	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)
-	}
-	сам := &MineNet{
-		СценаСеть: sectionNet,
-	}
-	return сам, nil
-}

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

@@ -6,14 +6,14 @@ import (
 	"strconv"
 	"strings"
 	"time"
-
 	"wartank/pkg/alias"
+	"wartank/pkg/arena"
+	"wartank/pkg/components/arena_net"
+	"wartank/pkg/components/kernel/logger"
 	"wartank/pkg/components/safe_int"
 	"wartank/pkg/components/safe_string"
 	"wartank/pkg/cons"
-	"wartank/pkg/section"
 	"wartank/pkg/types"
-	"wartank/server/serv_bots/warbot/angar/base/polygon/polygonnet"
 	"wartank/server/serv_bots/warbot/tank_stat/static_param"
 )
 
@@ -32,37 +32,34 @@ const (
 
 // Полигон -- объект полигона на базе
 type Полигон struct {
-	*section.Секция
+	types.ИАрена
 	бот           types.ИБот
 	танкСтат      types.ИТанкСтат
-	сеть          *polygonnet.ПолигонСеть
+	сеть          types.ИАренаСеть
 	продуктСейчас *safe_string.БезопСтрока
 	продуктКол    *safe_int.БезопЦелое
 	уровень       *static_param.СтатПарам
+	лог           types.ИЛоггер
 }
 
 // НовПолигон -- возвращает новый *Polygon
 func НовПолигон(база types.ИБаза) (*Полигон, error) {
-	секция, ош := section.НовСекция(база.Бот(), "Полигон", `<title>Полигон</title>`)
-	if ош != nil {
-		return nil, fmt.Errorf("НовПолигон(): при создании ИСекция, ош=\n\t%w", ош)
-	}
+	лог := logger.НовЛоггер("Полигон " + база.Бот().Имя())
+	лог.Инфо("НовПолигон(): бот=%s\n", база.Бот().Имя())
+	секция := arena.НовАрена(база.Бот(), "Полигон", `<title>Полигон</title>`)
 	уровень, ош := static_param.НовСтатПарам("уровень полигона")
 	if ош != nil {
 		return nil, fmt.Errorf("НовПолигон(): при создании уровня полигона, ош=\n\t%w", ош)
 	}
 	сам := &Полигон{
-		Секция:        секция,
+		ИАрена:        секция,
 		бот:           база.Бот(),
 		танкСтат:      база.Бот().Стата(),
 		продуктСейчас: safe_string.НовБезопСтрока(),
 		продуктКол:    safe_int.НовБезопЦелое(),
 		уровень:       уровень,
 	}
-	сам.сеть, ош = polygonnet.НовПолигонСеть(сам)
-	if ош != nil {
-		return nil, fmt.Errorf("NewPolygon(): in create NetPolygon, err=\n\t%w", ош)
-	}
+	сам.сеть = arena_net.НовАренаСеть(сам, "https://wartank.ru/polygon")
 	_ = types.ИБазаПолигон(сам)
 	return сам, nil
 }
@@ -105,6 +102,9 @@ func (сам *Полигон) пуск() {
 		сам.бот.Сервер().Отменить()
 		return
 	}
+	var (
+		еслиПостроить bool
+	)
 	фнРабота := func() {
 		defer func() {
 			for сам.ВремяОстат().ПолучМилСек() > 0 {
@@ -112,8 +112,13 @@ func (сам *Полигон) пуск() {
 				continue
 			}
 		}()
-		сам.построитьПровер()
-		сам.проверитьУскорение()
+		еслиПостроить = сам.построитьПровер() // Можно ли посторить?
+		if еслиПостроить {
+			if сам.проверитьУскорение() {
+				return
+			}
+		}
+
 		сам.усилениеДобавить()
 		сам.усилениеПровер()
 		сам.времяОбнов()
@@ -179,7 +184,7 @@ func (сам *Полигон) уровеньПолучить() bool {
 }
 
 // Проверяет на ускорение апгрейда полигона
-func (сам *Полигон) проверитьУскорение() {
+func (сам *Полигон) проверитьУскорение() bool {
 	var (
 		strOut      = ""
 		еслиНайдено bool
@@ -187,7 +192,7 @@ func (сам *Полигон) проверитьУскорение() {
 	lstBase, err := сам.сеть.ВебВоркер().Получ("https://wartank.ru/buildings")
 	if err != nil {
 		log.Printf("Полигон.проверитьУскорение(): при обновлении строк базы, err=\n\t%v\n", err)
-		return
+		return false
 	}
 	// Проверка на платное ускорение апгрейда + время
 	{ // Платное ускорение
@@ -195,11 +200,11 @@ func (сам *Полигон) проверитьУскорение() {
 			if err := сам.ОбратВремяУст(времОжидПлат); err != nil {
 				log.Printf("WARN Base.checkArsenalForce(): при установке платного времени ускорения апгрейда арсенала(%v)\n\terr=%v\n", времОжидПлат, err)
 			}
-			сам.СценаРежим().РаботаУст(стрАпгрейд)
-			сам.СценаРежим().РежимУст(cons.РежимАпгрейд)
+			сам.АренаСостояние().РаботаИмяУст("")
+			сам.АренаСостояние().СостояниеУст(cons.РежимАпгрейд)
 			сам.продуктСейчас.Уст(стрАпгрейд)
 			сам.продуктКол.Уст(0)
-			return
+			return true
 		}
 	}
 	{ // Проверка на бесплатное ускорение апгрейда
@@ -212,12 +217,12 @@ func (сам *Полигон) проверитьУскорение() {
 			}
 		}
 		if !еслиНайдено {
-			return
+			return false
 		}
 		if !strings.Contains(strOut, `>Ускорение<`) {
-			return
+			return false
 		}
-		сам.СценаРежим().РежимУст(cons.РежимАпгрейд)
+		сам.АренаСостояние().СостояниеУст(cons.РежимАпгрейд)
 		сам.продуктСейчас.Уст(стрАпгрейд)
 		сам.продуктКол.Уст(0)
 		lstLink := strings.Split(strOut, `<td style="width:50%;padding-left:1px;"><a class="simple-but border" href="`)
@@ -227,38 +232,65 @@ func (сам *Полигон) проверитьУскорение() {
 		lstBase, err := сам.сеть.Get(strLink)
 		if err != nil {
 			// log._rintf("ERRO NetBank.checkArsenalForce(): при GET-запросе на бесплатном ускорении апгрейда арсенала, err=\n\t%v\n", err)
-			return
+			return false
 		}
 		// sound.ArsenalForce()
 		if err := сам.СтрОбновить(lstBase); err != nil {
 			// log._rintf("ERRO NetBank.checkArsenalForce(): при обновлении lstBase, err=\n\t%v\n", err)
-			return
+			return false
 		}
-		сам.СценаРежим().РаботаУст(стрАпгрейд)
-		сам.СценаРежим().РежимУст(cons.РежимАпгрейд)
+		сам.АренаСостояние().РаботаИмяУст("")
+		сам.АренаСостояние().СостояниеУст(cons.РежимАпгрейд)
 		сам.продуктКол.Уст(0)
 		if err := сам.ОбратВремяУст(времОжидБесплат); err != nil {
 			log.Printf("WARN Base.checkArsenalForce(): при установке бесплатного времени ускорения апгрейда арсенала(%v)\n\terr=%v\n", времОжидБесплат, err)
 		}
 	}
 	// Все проверки прошли -- это просто работа
-	сам.СценаРежим().РаботаУст("work")
+	сам.АренаСостояние().РаботаИмяУст("work")
+	return true
 }
 
 // Проверяет необходимость постройки полигона
-func (сам *Полигон) построитьПровер() {
-	фнПостроить := func() bool { // Поиск кнопки строительства
-		// https://wartank.ru/building-upgrade/Polygon
-		списПолигон, ош := сам.сеть.ВебВоркер().Получ("https://wartank.ru/building-upgrade/Polygon")
-		if ош != nil {
-			log.Printf("Полигон.построитьПровер(): при чтении страницы строительства полигона, ош=\n\t%v\n", ош)
+func (сам *Полигон) построитьПровер() bool {
+	// https://wartank.ru/building-upgrade/Polygon
+	списПолигон, ош := сам.сеть.ВебВоркер().Получ("https://wartank.ru/building-upgrade/Polygon")
+	if ош != nil {
+		log.Printf("Полигон.построитьПровер(): при чтении страницы строительства полигона, ош=\n\t%v\n", ош)
+		return false
+	}
+	стрСсылка := ""
+	еслиНайти := false
+	// <a class="simple-but border mb5" href="Polygon?66-1.ILinkListener-upgradeLink-link">
+	for _, стрСсылка = range списПолигон {
+		if strings.Contains(стрСсылка, `href="Polygon?`) {
+			еслиНайти = true
+			break
+		}
+	}
+	if !еслиНайти { // Время полигона вышло
+		return false
+	}
+	_ссылка := strings.TrimPrefix(стрСсылка, `<a class="simple-but border mb5" href="`)
+	_ссылка = strings.TrimSuffix(_ссылка, `">`)
+	ссылка := "https://wartank.ru/building-upgrade/" + _ссылка
+	// https://wartank.ru/building-upgrade/Polygon?83-1.ILinkListener-upgradeLink-link
+	списПолигон, ош = сам.сеть.ВебВоркер().Получ(ссылка)
+	if ош != nil {
+		log.Printf("Полигон.построитьПровер(): при выполнении запроса на строительство, ош=\n\t%v\n", ош)
+		return false
+	}
+	for _, стр := range списПолигон {
+		if strings.Contains(стр, `href="Polygon?`) {
 			return false
 		}
+	}
+	{ // подтверждение постройки
+		// "<a class=\"simple-but border w50 mXa mb10\" w:id=\"confirmLink\" href=\"../wicket/page?13-1.ILinkListener-confirmLink\"><span><span>да, подтверждаю</span></span></a>"
 		стрСсылка := ""
 		еслиНайти := false
-		// <a class="simple-but border mb5" href="Polygon?66-1.ILinkListener-upgradeLink-link">
 		for _, стрСсылка = range списПолигон {
-			if strings.Contains(стрСсылка, `href="Polygon?`) {
+			if strings.Contains(стрСсылка, `.ILinkListener-confirmLink`) {
 				еслиНайти = true
 				break
 			}
@@ -266,47 +298,19 @@ func (сам *Полигон) построитьПровер() {
 		if !еслиНайти { // Время полигона вышло
 			return false
 		}
-		_ссылка := strings.TrimPrefix(стрСсылка, `<a class="simple-but border mb5" href="`)
-		_ссылка = strings.TrimSuffix(_ссылка, `">`)
-		ссылка := "https://wartank.ru/building-upgrade/" + _ссылка
-		// https://wartank.ru/building-upgrade/Polygon?83-1.ILinkListener-upgradeLink-link
-		списПолигон, ош = сам.сеть.ВебВоркер().Получ(ссылка)
+		_ссылка := strings.TrimPrefix(стрСсылка, "<a class=\"simple-but border w50 mXa mb10\" w:id=\"confirmLink\" href=\"../")
+		_ссылка = strings.TrimSuffix(_ссылка, "\"><span><span>да, подтверждаю</span></span></a>")
+		ссылка := "https://wartank.ru/" + _ссылка
+		// https://wartank.ru/wicket/page?135-1.ILinkListener-confirmLink
+		_, ош = сам.сеть.ВебВоркер().Получ(ссылка)
 		if ош != nil {
 			log.Printf("Полигон.построитьПровер(): при выполнении запроса на строительство, ош=\n\t%v\n", ош)
 			return false
 		}
-		for _, стр := range списПолигон {
-			if strings.Contains(стр, `href="Polygon?`) {
-				return false
-			}
-		}
-		{ // подтверждение постройки
-			// "<a class=\"simple-but border w50 mXa mb10\" w:id=\"confirmLink\" href=\"../wicket/page?13-1.ILinkListener-confirmLink\"><span><span>да, подтверждаю</span></span></a>"
-			стрСсылка := ""
-			еслиНайти := false
-			for _, стрСсылка = range списПолигон {
-				if strings.Contains(стрСсылка, `.ILinkListener-confirmLink`) {
-					еслиНайти = true
-					break
-				}
-			}
-			if !еслиНайти { // Время полигона вышло
-				return false
-			}
-			_ссылка := strings.TrimPrefix(стрСсылка, "<a class=\"simple-but border w50 mXa mb10\" w:id=\"confirmLink\" href=\"../")
-			_ссылка = strings.TrimSuffix(_ссылка, "\"><span><span>да, подтверждаю</span></span></a>")
-			ссылка := "https://wartank.ru/" + _ссылка
-			// https://wartank.ru/wicket/page?135-1.ILinkListener-confirmLink
-			_, ош = сам.сеть.ВебВоркер().Получ(ссылка)
-			if ош != nil {
-				log.Printf("Полигон.построитьПровер(): при выполнении запроса на строительство, ош=\n\t%v\n", ош)
-				return false
-			}
-		}
-		return true
 	}
-	фнПостроить()
-	log.Printf("Полигон.построитьПровер(): построен упешно\n")
+
+	сам.лог.Инфо("Полигон.построитьПровер(): построен упешно\n")
+	return true
 }
 
 // Обновляет оставшееся время полигона
@@ -343,7 +347,7 @@ func (сам *Полигон) времяОбнов() {
 	strLastTime = lstTime[1]
 	lstTime = strings.Split(strLastTime, `</span>`)
 	strLastTime = lstTime[0]
-	if err := сам.Уст(alias.Время(strLastTime)); err != nil {
+	if err := сам.ОбратВремяУст(alias.Время(strLastTime)); err != nil {
 		// log._rintf("ERRO Polygon.updateTime(): при установке времени ожидания полигона(%v)\n\terr=%v\n", strLastTime, err)
 		return
 	}
@@ -399,13 +403,11 @@ func (сам *Полигон) усилениеПровер() {
 
 // Выбирает самый слабый параметр и усиливает его
 func (сам *Полигон) усилениеДобавить() {
-	if ош := сам.сеть.Обновить(); ош != nil {
-		// log._rintf("Polygon.checkPolygon(): при принудительном обновлении lstPlygon, mode=%s\terr=\n\t%v\n", сам.ModeCurrent().Get(), err)
-		if err := сам.ОбратВремяУст("05"); err != nil {
-			log.Printf("Polygon.checkPolygon(): при принудительном обновлении обратного времени, время=`05`\terr=\n\t%v\n", err)
-			сам.бот.Сервер().Отменить()
-			return
-		}
+	сам.сеть.Обновить()
+	// log._rintf("Polygon.checkPolygon(): при принудительном обновлении lstPlygon, mode=%s\terr=\n\t%v\n", сам.ModeCurrent().Get(), err)
+	if err := сам.ОбратВремяУст("05"); err != nil {
+		log.Printf("Polygon.checkPolygon(): при принудительном обновлении обратного времени, время=`05`\terr=\n\t%v\n", err)
+		сам.бот.Сервер().Отменить()
 		return
 	}
 	lstPoligon := сам.СписПолучить()
@@ -486,7 +488,7 @@ func (сам *Полигон) усилениеДобавить() {
 				return
 			}
 			сам.танкСтат.ФорсажОбнов("attack", iForce)
-			сам.СценаРежим().РаботаУст(стрАтака)
+			сам.АренаСостояние().РаботаИмяУст(стрАтака)
 		}
 	case стрБроня: // Усиливаем броню
 		еслиНайдено = false
@@ -524,7 +526,7 @@ func (сам *Полигон) усилениеДобавить() {
 				return
 			}
 			сам.танкСтат.ФорсажОбнов(стрБроня, iForce)
-			сам.СценаРежим().РаботаУст(стрБроня)
+			сам.АренаСостояние().РаботаИмяУст(стрБроня)
 		}
 	case стрТочность: // Усиливаем точность
 		еслиНайдено = false
@@ -562,7 +564,7 @@ func (сам *Полигон) усилениеДобавить() {
 				return
 			}
 			сам.танкСтат.ФорсажОбнов(стрТочность, iForce)
-			сам.СценаРежим().РаботаУст(стрТочность)
+			сам.АренаСостояние().РаботаИмяУст(стрТочность)
 		}
 	case стрПрочность: // Усиливаем мощность
 		еслиНайдено = false
@@ -597,10 +599,10 @@ func (сам *Полигон) усилениеДобавить() {
 				return
 			}
 			сам.танкСтат.ФорсажОбнов(стрПрочность, iForce)
-			сам.СценаРежим().РаботаУст(стрПрочность)
+			сам.АренаСостояние().РаботаИмяУст(стрПрочность)
 		}
 	default: // Неизвестно что
-		сам.СценаРежим().РаботаУст("неизвестно")
+		сам.АренаСостояние().РаботаИмяУст("неизвестно")
 		// log._rintf("ERRO NetPolygon.addForce(): неизвестно что это, strParam=%q", strParam)
 		return
 	}

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

@@ -1,31 +0,0 @@
-package polygonnet
-
-import (
-	"fmt"
-
-	"wartank/pkg/components/scene_net"
-	"wartank/pkg/types"
-)
-
-/*
-	Опрашивает полигон в сети
-*/
-
-// ПолигонСеть -- опрашивает полигон на базе
-type ПолигонСеть struct {
-	*scene_net.СценаСеть
-}
-
-// НовПолигонСеть -- возвращает новый *PolygonNet
-func НовПолигонСеть(polygon types.ИБазаПолигон) (*ПолигонСеть, error) {
-	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)
-	}
-
-	сам := &ПолигонСеть{
-		СценаСеть: sectionNet,
-	}
-
-	return сам, nil
-}

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

@@ -4,7 +4,7 @@ package battle
 import (
 	"fmt"
 	"time"
-	"wartank/pkg/section"
+	"wartank/pkg/arena"
 	"wartank/pkg/types"
 	"wartank/server/serv_bots/warbot/angar/battle/battle_register"
 	"wartank/server/serv_bots/warbot/angar/battle/battle_wait"
@@ -13,7 +13,7 @@ import (
 
 // Сражение -- объект сражения
 type Сражение struct {
-	*section.Секция
+	*arena.Арена
 	бот    types.ИБот
 	клиент types.ИВебВоркер
 
@@ -25,25 +25,16 @@ type Сражение struct {
 
 // НовСражение -- возвращает новый *Battle
 func НовСражение(бот types.ИБот) (*Сражение, error) {
-	секция, ош := section.НовСекция(бот, "Группа сражения", `<span>до начала `)
-	if ош != nil {
-		return nil, fmt.Errorf("НовСражение(): in create *Section, err=\n\t%w", ош)
-	}
-
+	секция := arena.НовАрена(бот, "Группа сражения", `<span>до начала `)
 	сам := &Сражение{
-		Секция: секция,
+		Арена:  секция,
 		бот:    бот,
 		клиент: бот.Сеть().ВебВоркер(),
 	}
+	var ош error
 	{
-		сам.регистрация, ош = battle_register.НовСражениеРегистрация(бот)
-		if ош != nil {
-			return nil, fmt.Errorf("НовСражение(): при создании регистратора на сражения, err=\n\t%w", ош)
-		}
-		сам.ожидание, ош = battle_wait.НовСражениеОжидание(бот)
-		if ош != nil {
-			return nil, fmt.Errorf("НовСражение(): при создании ожидателя сражения, err=\n\t%w", ош)
-		}
+		сам.регистрация = battle_register.НовСражениеРегистрация(бот)
+		сам.ожидание = battle_wait.НовСражениеОжидание(бот)
 		сам.действие, ош = battle_worker.НовСражениеИсполнитель(бот)
 		if ош != nil {
 			return nil, fmt.Errorf("НовСражение(): при создании исполнителя сражения, err=\n\t%w", ош)

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

@@ -2,40 +2,32 @@
 package battle_register
 
 import (
-	"fmt"
 	"log"
 	"strings"
 	"time"
-
-	"wartank/pkg/components/scene_net"
-	"wartank/pkg/section"
+	"wartank/pkg/arena"
+	"wartank/pkg/components/arena_net"
 	"wartank/pkg/types"
 )
 
 // СражениеРегистрация -- регистрирует танк к началу атаки
 type СхваткаРегистрация struct {
-	*section.Секция
+	types.ИАрена
 	бот          types.ИБот
-	сеть         *scene_net.СценаСеть
+	сеть         types.ИАренаСеть
 	счётРегистер int // Счётчик регистраций на сражение
 }
 
 // НовСражениеРегистрация -- возвращает новый ожидатель битвы
-func НовСражениеРегистрация(бот types.ИБот) (*СхваткаРегистрация, error) {
-	секция, ош := section.НовСекция(бот, "Сражение", `<title>Сражения</title>`)
-	if ош != nil {
-		return nil, fmt.Errorf("НовСражениеРегистрация(): in create ISection, err=\n\t%w", ош)
-	}
+func НовСражениеРегистрация(бот types.ИБот) *СхваткаРегистрация {
+	секция := arena.НовАрена(бот, "Сражение", `<title>Сражения</title>`)
 	сам := &СхваткаРегистрация{
-		Секция:       секция,
+		ИАрена:       секция,
 		бот:          бот,
 		счётРегистер: 10_000,
 	}
-	сам.сеть, ош = scene_net.НовСекцияСеть(сам, "https://wartank.ru/pve")
-	if ош != nil {
-		return nil, fmt.Errorf("НовСражениеРегистрация(): in create *SectionNet, err=\n\t%w", ош)
-	}
-	return сам, nil
+	сам.сеть = arena_net.НовАренаСеть(сам, "https://wartank.ru/pve")
+	return сам
 }
 
 // Зарегистрироваться -- регистрирует танк на сражение

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

@@ -2,40 +2,30 @@
 package battle_wait
 
 import (
-	"fmt"
-	// "log"
 	"strings"
 	"time"
-
 	"wartank/pkg/alias"
-	"wartank/pkg/components/scene_net"
-	"wartank/pkg/section"
+	"wartank/pkg/arena"
+	"wartank/pkg/components/arena_net"
 	"wartank/pkg/types"
 )
 
 // СражениеОжидание -- ожидатель начала битвы
 type СхваткаОжидание struct {
-	*section.Секция
-	bot types.ИБот
-	net *scene_net.СценаСеть
+	types.ИАрена
+	бот  types.ИБот
+	сеть types.ИАренаСеть
 }
 
 // НовСражениеОжидание -- возвращает новый ожидатель битвы
-func НовСражениеОжидание(bot types.ИБот) (*СхваткаОжидание, error) {
-	section, err := section.НовСекция(bot, "Ожидание сражения", `<title>Сражения</title>`)
-	if err != nil {
-		return nil, fmt.Errorf("NewBattleWait(): in create ISection, err=\n\t%w", err)
-	}
-
+func НовСражениеОжидание(бот types.ИБот) *СхваткаОжидание {
+	арена := arena.НовАрена(бот, "Ожидание сражения", `<title>Сражения</title>`)
 	сам := &СхваткаОжидание{
-		Секция: section,
-		bot:    bot,
+		ИАрена: арена,
+		бот:    бот,
 	}
-	сам.net, err = scene_net.НовСекцияСеть(сам, "https://wartank.ru/pve")
-	if err != nil {
-		return nil, fmt.Errorf("NewBattleWait(): in create *SectionNet, err=\n\t%w", err)
-	}
-	return сам, nil
+	сам.сеть = arena_net.НовАренаСеть(сам, "https://wartank.ru/pve")
+	return сам
 }
 
 // Ожидать -- ожидает начало сражения
@@ -78,9 +68,7 @@ func (сам *СхваткаОжидание) Ожидать() {
 
 // Ждёт пока время не обнулится
 func (сам *СхваткаОжидание) ждать() string {
-	if ош := сам.net.Обновить(); ош != nil { // Здесь может уже обратный отсчёт перед сражением
-		return ""
-	}
+	сам.сеть.Обновить()
 	var (
 		strOut      string
 		lstBattle   = сам.СписПолучить()
@@ -106,7 +94,7 @@ func (сам *СхваткаОжидание) ждать() string {
 	strTime := lstTime[1]
 	lstTime = strings.Split(strTime, ` (`)
 	strTime = lstTime[0]
-	if err := сам.Секция.Уст(alias.Время(strTime)); err != nil { // Возможно уже всё
+	if err := сам.ОбратВремяУст(alias.Время(strTime)); err != nil { // Возможно уже всё
 		// log._rintf("WARN BattleWait.Wait(): при установке времени ожидания сражения(%v)\n\terr=%v\n", strTime, err)
 		return ""
 	}

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

@@ -4,9 +4,8 @@ package battle_worker
 import (
 	"fmt"
 	"time"
-
-	"wartank/pkg/components/scene_net"
-	"wartank/pkg/section"
+	"wartank/pkg/arena"
+	"wartank/pkg/components/arena_net"
 	"wartank/pkg/types"
 	"wartank/server/serv_bots/warbot/angar/battle/battle_worker/battleon"
 	"wartank/server/serv_bots/warbot/angar/battle/battle_worker/battleon/battlesound"
@@ -15,9 +14,9 @@ import (
 
 // СражениеДействие -- исполнение битвы
 type СхваткаИсполнитель struct {
-	*section.Секция
+	types.ИАрена
 	бот  types.ИБот
-	сеть *scene_net.СценаСеть
+	сеть types.ИАренаСеть
 
 	еслиНачало types.ИСтатПарам
 
@@ -29,34 +28,24 @@ type СхваткаИсполнитель struct {
 
 // НовСражениеДействие -- возвращает новый исполнитель битвы
 func НовСражениеИсполнитель(bot types.ИБот) (*СхваткаИсполнитель, error) {
-	section, err := section.НовСекция(bot, "Ход сражения", `<title>Сражения</title>`)
-	if err != nil {
-		return nil, fmt.Errorf("NewBattleWorker(): in create *Section, err=\n\t%w", err)
-	}
+	section := arena.НовАрена(bot, "Ход сражения", `<title>Сражения</title>`)
 	еслиНачало, ош := static_param.НовСтатПарам("alarm")
 	if ош != nil {
 		return nil, fmt.Errorf("NewBattleWorker(): при создании стат еслиНачало, err=\n\t%w", ош)
 	}
 	сам := &СхваткаИсполнитель{
-		Секция:     section,
+		ИАрена:     section,
 		бот:        bot,
 		еслиНачало: еслиНачало,
 		sound:      battlesound.NewBattleSound(),
 	}
-	сам.сеть, err = scene_net.НовСекцияСеть(сам, "https://wartank.ru/pve")
-	if err != nil {
-		return nil, fmt.Errorf("NewBattleWorker(): in create *SectionNet, err=\n\t%w", err)
-	}
+	сам.сеть = arena_net.НовАренаСеть(сам, "https://wartank.ru/pve")
 	return сам, nil
 }
 
 // Танковать -- выполняет битву
 func (сам *СхваткаИсполнитель) Танковать() {
-	var ош error
-	сам.действие, ош = battleon.НовСражениеДействие(сам.бот) // IBattleOn (онлайн)
-	if ош != nil {
-		return
-	}
+	сам.действие = battleon.НовСражениеДействие(сам.бот) // IBattleOn (онлайн)
 	сам.sound.Play()
 	time.Sleep(time.Second * 10) // Задержка для звука на странице
 	<-сам.действие.Контекст().Done()

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

@@ -2,10 +2,9 @@ package battleon
 
 import (
 	"context"
-	"fmt"
 	"time"
-	"wartank/pkg/components/scene_net"
-	"wartank/pkg/section"
+	"wartank/pkg/arena"
+	"wartank/pkg/components/arena_net"
 	"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"
@@ -19,8 +18,8 @@ import (
 
 // СражениеДействие -- непосредственно танкует в сражении
 type СражениеДействие struct {
-	*section.Секция
-	сеть       types.ИСценаСеть
+	types.ИАрена
+	сеть       types.ИАренаСеть
 	бот        types.ИБот
 	кнт        context.Context // Контекст сражения
 	фнОтменить func()          // Функция отмены сражения
@@ -33,29 +32,22 @@ type СражениеДействие struct {
 }
 
 // НовСражениеДействие -- возвращает новый *BattleOn
-func НовСражениеДействие(бот types.ИБот) (*СражениеДействие, error) {
-	секция, ош := section.НовСекция(бот, "Исполнитель сражения", `<title>Сражения</title>`)
-	if ош != nil {
-		return nil, fmt.Errorf("НовСражениеДействие(): in create ISection, err=\n\t%w", ош)
-	}
-
+func НовСражениеДействие(бот types.ИБот) *СражениеДействие {
+	секция := arena.НовАрена(бот, "Исполнитель сражения", `<title>Сражения</title>`)
 	// Ограничить время сражения бота
 	кнтСражение, фнОтменить := context.WithTimeout(бот.Контекст(), time.Second*305)
 	сам := &СражениеДействие{
-		Секция:      секция,
+		ИАрена:      секция,
 		бот:         бот,
 		кнт:         кнтСражение,
 		фнОтменить:  фнОтменить,
 		логин:       бот.Имя(),
 		еслиВыстрел: isshot.NewIsShot(),
 	}
-	сам.сеть, ош = scene_net.НовСекцияСеть(сам, "https://wartank.ru/pve")
-	if ош != nil {
-		return nil, fmt.Errorf("NewBattleOn(): in create *SectionNet, err=\n\t%w", ош)
-	}
+	сам.сеть = arena_net.НовАренаСеть(сам, "https://wartank.ru/pve")
 	go сам.пуск()
 	_ = types.ИСражениеДействие(сам)
-	return сам, nil
+	return сам
 }
 
 // запускает сражение
@@ -87,7 +79,7 @@ func (сам *СражениеДействие) пуск() {
 }
 
 // Сеть -- возвращает сетевой компонент секции
-func (сам *СражениеДействие) Сеть() types.ИСценаСеть {
+func (сам *СражениеДействие) Сеть() types.ИАренаСеть {
 	return сам.сеть
 }
 

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

@@ -5,7 +5,6 @@ import (
 	// "log"
 	"strings"
 	"time"
-
 	"wartank/pkg/types"
 )
 
@@ -73,12 +72,7 @@ func (сам *Выстрел) пуск() {
 //
 //	Вызывается из отдельного потока
 func (сам *Выстрел) выстрел() {
-	if ош := сам.Сеть().Обновить(); ош != nil { // Проверка на непосредственно битву
-		// <span>закончилась 00:00:07 назад</span>
-		// log._rintf("ERRO Shot.shot(): при обновлении lstBattleOn, err=\n\t%v\n", err)
-		сам.Отменить()
-		return
-	}
+	сам.Сеть().Обновить()
 
 	// <a href="pve?6-26.ILinkListener-currentControl-attackRegularShellLink" class="simple-but gray"><span><span>ОБЫЧНЫЕ</span></span></a>
 

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

@@ -1,8 +1,7 @@
 package battlenet
 
 import (
-	"fmt"
-	"wartank/pkg/components/scene_net"
+	"wartank/pkg/components/arena_net"
 	"wartank/pkg/types"
 )
 
@@ -12,17 +11,14 @@ import (
 
 // BattleNet -- танкует в сражении
 type BattleNet struct {
-	*scene_net.СценаСеть
+	types.ИАренаСеть
 }
 
 // NewBattleNet -- возвращает новый *BattleNet
-func NewBattleNet(battle types.ИСражениеСцена) (*BattleNet, error) {
-	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)
-	}
+func NewBattleNet(battle types.ИСражениеСцена) *BattleNet {
+	sectionNet := arena_net.НовАренаСеть(battle, "https://wartank.ru/pve")
 	сам := &BattleNet{
-		СценаСеть: sectionNet,
+		ИАренаСеть: sectionNet,
 	}
-	return сам, nil
+	return сам
 }

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

@@ -7,9 +7,9 @@ import (
 	"strings"
 	"time"
 	"wartank/pkg/alias"
-	"wartank/pkg/section"
+	"wartank/pkg/arena"
+	"wartank/pkg/components/arena_net"
 	"wartank/pkg/types"
-	"wartank/server/serv_bots/warbot/angar/convoy/convoynet"
 	"wartank/server/serv_bots/warbot/tank_stat/static_param"
 )
 
@@ -19,31 +19,25 @@ import (
 
 // Конвой -- объект конвоя в ангаре
 type Конвой struct {
-	*section.Секция
-	net   *convoynet.ConvoyNet
+	types.ИАрена
+	сеть  types.ИАренаСеть
 	бот   types.ИБот
 	слава types.ИСтатПарам // Количество славы
 }
 
 // НовКонвой -- возвращает новый *Convoy
-func НовКонвой(bot types.ИБот) (*Конвой, error) {
-	section, err := section.НовСекция(bot, "Конвой", `<title>Конвой</title>`)
-	if err != nil {
-		return nil, fmt.Errorf("НовКонвой(): in create ISection, err=\n\t%w", err)
-	}
+func НовКонвой(бот types.ИБот) (*Конвой, error) {
+	арена := arena.НовАрена(бот, "Конвой", `<title>Конвой</title>`)
 	слава, ош := static_param.НовСтатПарам("glory")
 	if ош != nil {
 		return nil, fmt.Errorf("НовКонвой(): при создании статы славы, err=\n\t%w", ош)
 	}
 	сам := &Конвой{
-		Секция: section,
-		бот:    bot,
+		ИАрена: арена,
+		бот:    бот,
 		слава:  слава,
 	}
-	сам.net, err = convoynet.NewConvoyNet(сам)
-	if err != nil {
-		return nil, fmt.Errorf("НовКонвой(): in create *SectionNet, err=\n\t%w", err)
-	}
+	сам.сеть = arena_net.НовАренаСеть(сам, "https://wartank.ru/convoy")
 	return сам, nil
 }
 
@@ -55,9 +49,7 @@ func (сам *Конвой) Пуск() error {
 
 // UpdateLst -- принудительно обновляет состояние конвоя
 func (сам *Конвой) UpdateLst() {
-	if err := сам.net.Обновить(); err != nil {
-		log.Printf("Конвой.UpdateLst(): err=\n\t%v\n", err)
-	}
+	сам.сеть.Обновить()
 }
 
 // Слава --возвращает счётчик славы конвоя
@@ -135,14 +127,11 @@ func (сам *Конвой) Обновить() {
 // Обновляет оставшееся время конвоя
 func (сам *Конвой) обновитьВремя() {
 	// Время подходит надо обновляться
-	if err := сам.net.Обновить(); err != nil {
-		log.Printf("Конвой.обновитьВремя(): при выполнении GET-команды обновления, err=\n\t%v\n", err)
-		ош := сам.ОбратВремяУст("20")
-		if ош != nil {
-			log.Printf("Конвой.обновитьВремя(): при обновлении времени, ош=\n\t%v\n", ош)
-			сам.бот.Сервер().Отменить()
-			return
-		}
+	сам.сеть.Обновить()
+	ош := сам.ОбратВремяУст("20")
+	if ош != nil {
+		log.Printf("Конвой.обновитьВремя(): при обновлении времени, ош=\n\t%v\n", ош)
+		сам.бот.Сервер().Отменить()
 		return
 	}
 	// Найти строку с упоминанием оставшегося времени конвоя
@@ -180,7 +169,7 @@ func (сам *Конвой) обновитьВремя() {
 		// Ждём окончания ожидания конвоя
 		lstTime := strings.Split(strLastTime, `До следующего конвоя: `)
 		strLastTime = lstTime[1]
-		if err := сам.Уст(alias.Время(strLastTime)); err != nil {
+		if err := сам.ОбратВремяУст(alias.Время(strLastTime)); err != nil {
 			// log._rintf("WARN Конвой.обновитьВремя(): при установке времени ожидания конвоя(%v)\n\terr=%v\n", strLastTime, err)
 			err := сам.ОбратВремяУст("10")
 			if err != nil {
@@ -192,7 +181,7 @@ func (сам *Конвой) обновитьВремя() {
 		// Ждём окончания ожидания конвоя
 		lstTime := strings.Split(strLastTime, `Полная маскировка через `)
 		strLastTime = lstTime[1]
-		if err := сам.Уст(alias.Время(strLastTime)); err != nil {
+		if err := сам.ОбратВремяУст(alias.Время(strLastTime)); err != nil {
 			// log._rintf("ERRO BКонвой.обновитьВремя(): при установке времени банка для 1го режима(%v)\n\terr=%v\n", strLastTime, err)
 			err := сам.ОбратВремяУст("10")
 			if err != nil {
@@ -208,7 +197,7 @@ func (сам *Конвой) найтиВбой() string {
 		strOut      = ""
 		еслиНайдено bool
 	)
-	lstConvoy, err := сам.net.ВебВоркер().Получ("https://wartank.ru/convoy")
+	lstConvoy, err := сам.сеть.ВебВоркер().Получ("https://wartank.ru/convoy")
 	if err != nil {
 		log.Printf("Конвой.атакаНачать(): при обновлении lstConvoy, ош=\n\t%v\n", err)
 		return ""
@@ -277,7 +266,7 @@ func (сам *Конвой) атакаНачать() {
 	}
 	strLink := strOut
 	// Можно начать разведку
-	lstConvoy, err := сам.net.ВебВоркер().Получ(strLink)
+	lstConvoy, err := сам.сеть.ВебВоркер().Получ(strLink)
 	if err != nil {
 		log.Printf("ERRO Конвой.атакаНачать(): при выполнении GET-команды 'В атаку!', err=\n\t%v\n", err)
 		return
@@ -327,7 +316,7 @@ func (сам *Конвой) начатьРазведку() {
 	link := "https://wartank.ru/" + _link
 	{ // Выполнить атаку
 		var err error
-		lstConvoy, err = сам.net.ВебВоркер().Получ(link)
+		lstConvoy, err = сам.сеть.ВебВоркер().Получ(link)
 		if err != nil {
 			log.Printf("Конвой.attack(): in get page find attack, err=\n\t%v\n", err)
 			return
@@ -345,10 +334,7 @@ func (сам *Конвой) проверитьМиссияРазведкаКон
 		strOut      string
 		еслиНайдено bool
 	)
-	if err := сам.net.Обновить(); err != nil {
-		// log._rintf("Конвой.проверитьМиссияРазведкаКонвой(): при обновлении пустого lstConvoy, err=\n\t%v\n", err)
-		return
-	}
+	сам.сеть.Обновить()
 	lstConvoy := сам.СписПолучить()
 	// <a class="simple-but border" href="convoy?21-1.ILinkListener-missions-cc-0-c-awardLink"><span><span>Получить награду</span></span></a>
 	for _, strOut = range lstConvoy {
@@ -365,7 +351,7 @@ func (сам *Конвой) проверитьМиссияРазведкаКон
 	_ссылка = strings.TrimSuffix(_ссылка, `"><span><span>Получить награду</span></span></a>`)
 	// https://wartank.ru/convoy?23-1.ILinkListener-missions-cc-0-c-awardLink
 	ссылка := "https://wartank.ru/" + _ссылка
-	lstConvoy, err := сам.net.ВебВоркер().Получ(ссылка)
+	lstConvoy, err := сам.сеть.ВебВоркер().Получ(ссылка)
 	if err != nil {
 		log.Printf("Конвой.проверитьМиссияРазведкаКонвой(): при выполнени команды GET, err=\n\t%v\n", err)
 		return
@@ -386,10 +372,7 @@ func (сам *Конвой) проверитьМиссияМастерРазве
 		ind         int
 	)
 	if len(lstConvoy) == 0 {
-		if err := сам.net.Обновить(); err != nil {
-			// log._rintf("Конвой.проверитьМиссияМастерРазведки(): при обновлении пустого lstConvoy, err=\n\t%v\n", err)
-			return
-		}
+		сам.сеть.Обновить()
 		lstConvoy = сам.СписПолучить()
 	}
 	for ind, strOut = range lstConvoy {
@@ -412,7 +395,7 @@ func (сам *Конвой) проверитьМиссияМастерРазве
 	lstLink = strings.Split(strLink, `"><span><span>Получить награду</span></span></a>`)
 	// https://wartank.ru/convoy?61-1.ILinkListener-missions-cc-0-c-awardLink
 	strLink = "https://wartank.ru/" + lstLink[0]
-	lstConvoy, err := сам.net.Get(strLink)
+	lstConvoy, err := сам.сеть.Get(strLink)
 	if err != nil {
 		// log._rintf("ERRO Конвой.checkMaster(): при выполнени команды GET, err=\n\t%v\n", err)
 		return
@@ -430,10 +413,7 @@ func (сам *Конвой) проверитьМиссия6фрагов() {
 		strOut      string
 		еслиНайдено bool
 	)
-	if err := сам.net.Обновить(); err != nil {
-		// log._rintf("Конвой.check6frage(): при обновлении пустого lstConvoy, err=\n\t%v\n", err)
-		return
-	}
+	сам.сеть.Обновить()
 	lstConvoy := сам.СписПолучить()
 	// <a class="simple-but border" href="convoy?8-1.ILinkListener-missions-cc-1-c-awardLink"><span><span>Получить награду</span></span></a>
 	for _, strOut = range lstConvoy {
@@ -450,7 +430,7 @@ func (сам *Конвой) проверитьМиссия6фрагов() {
 	_ссылка = strings.TrimSuffix(_ссылка, `"><span><span>Получить награду</span></span></a>`)
 	// https://wartank.ru/convoy?15-1.ILinkListener-missions-cc-1-c-awardLink
 	ссылка := "https://wartank.ru/" + _ссылка
-	lstConvoy, ош := сам.net.ВебВоркер().Получ(ссылка)
+	lstConvoy, ош := сам.сеть.ВебВоркер().Получ(ссылка)
 	if ош != nil {
 		log.Printf("Конвой.проверитьМиссия6фрагов(): при выполнени команды GET, err=\n\t%v\n", ош)
 		return

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

@@ -1,28 +0,0 @@
-package convoynet
-
-import (
-	"fmt"
-	"wartank/pkg/components/scene_net"
-	"wartank/pkg/types"
-)
-
-/*
-	Автоматически воюет с конвоем в сети
-*/
-
-// ConvoyNet -- танкует с конвоем в сети
-type ConvoyNet struct {
-	*scene_net.СценаСеть
-}
-
-// NewConvoyNet -- возвращает новый *ConvoyNet
-func NewConvoyNet(convoy types.Конвой) (*ConvoyNet, error) {
-	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)
-	}
-	сам := &ConvoyNet{
-		СценаСеть: sectionNet,
-	}
-	return сам, nil
-}

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

@@ -4,7 +4,7 @@ package death_match
 import (
 	"fmt"
 	"time"
-	"wartank/pkg/section"
+	"wartank/pkg/arena"
 	"wartank/pkg/types"
 	"wartank/server/serv_bots/warbot/angar/battle/battle_register"
 	"wartank/server/serv_bots/warbot/angar/battle/battle_wait"
@@ -13,7 +13,7 @@ import (
 
 // Сражение -- объект схватки
 type Схватка struct {
-	*section.Секция
+	*arena.Арена
 	бот    types.ИБот
 	клиент types.ИВебВоркер
 
@@ -25,25 +25,16 @@ type Схватка struct {
 
 // НовСражение -- возвращает новый *Battle
 func НовСхватка(бот types.ИБот) (*Схватка, error) {
-	секция, ош := section.НовСекция(бот, "Группа схватки", `<span>до начала `)
-	if ош != nil {
-		return nil, fmt.Errorf("НовСражение(): in create *Section, err=\n\t%w", ош)
-	}
-
+	секция := arena.НовАрена(бот, "Группа схватки", `<span>до начала `)
 	сам := &Схватка{
-		Секция: секция,
+		Арена:  секция,
 		бот:    бот,
 		клиент: бот.Сеть().ВебВоркер(),
 	}
+	var ош error
 	{
-		сам.регистрация, ош = battle_register.НовСражениеРегистрация(бот)
-		if ош != nil {
-			return nil, fmt.Errorf("НовСражение(): при создании регистратора на схватки, err=\n\t%w", ош)
-		}
-		сам.ожидание, ош = battle_wait.НовСражениеОжидание(бот)
-		if ош != nil {
-			return nil, fmt.Errorf("НовСражение(): при создании ожидателя схватки, err=\n\t%w", ош)
-		}
+		сам.регистрация = battle_register.НовСражениеРегистрация(бот)
+		сам.ожидание = battle_wait.НовСражениеОжидание(бот)
 		сам.действие, ош = battle_worker.НовСражениеИсполнитель(бот)
 		if ош != nil {
 			return nil, fmt.Errorf("НовСражение(): при создании исполнителя схватки, err=\n\t%w", ош)

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

@@ -2,40 +2,30 @@
 package battle_wait
 
 import (
-	"fmt"
-	// "log"
 	"strings"
 	"time"
-
 	"wartank/pkg/alias"
-	"wartank/pkg/components/scene_net"
-	"wartank/pkg/section"
+	"wartank/pkg/arena"
+	"wartank/pkg/components/arena_net"
 	"wartank/pkg/types"
 )
 
 // СражениеОжидание -- ожидатель начала битвы
 type СражениеОжидание struct {
-	*section.Секция
-	bot types.ИБот
-	net *scene_net.СценаСеть
+	types.ИАрена
+	бот  types.ИБот
+	сеть types.ИАренаСеть
 }
 
 // НовСражениеОжидание -- возвращает новый ожидатель битвы
-func НовСражениеОжидание(bot types.ИБот) (*СражениеОжидание, error) {
-	section, err := section.НовСекция(bot, "Ожидание сражения", `<title>Сражения</title>`)
-	if err != nil {
-		return nil, fmt.Errorf("NewBattleWait(): in create ISection, err=\n\t%w", err)
-	}
-
+func НовСражениеОжидание(бот types.ИБот) *СражениеОжидание {
+	арена := arena.НовАрена(бот, "Ожидание сражения", `<title>Сражения</title>`)
 	сам := &СражениеОжидание{
-		Секция: section,
-		bot:    bot,
+		ИАрена: арена,
+		бот:    бот,
 	}
-	сам.net, err = scene_net.НовСекцияСеть(сам, "https://wartank.ru/pve")
-	if err != nil {
-		return nil, fmt.Errorf("NewBattleWait(): in create *SectionNet, err=\n\t%w", err)
-	}
-	return сам, nil
+	сам.сеть = arena_net.НовАренаСеть(сам, "https://wartank.ru/pve")
+	return сам
 }
 
 // Ожидать -- ожидает начало сражения
@@ -78,9 +68,7 @@ func (сам *СражениеОжидание) Ожидать() {
 
 // Ждёт пока время не обнулится
 func (сам *СражениеОжидание) ждать() string {
-	if ош := сам.net.Обновить(); ош != nil { // Здесь может уже обратный отсчёт перед сражением
-		return ""
-	}
+	сам.сеть.Обновить()
 	var (
 		strOut      string
 		lstBattle   = сам.СписПолучить()
@@ -106,7 +94,7 @@ func (сам *СражениеОжидание) ждать() string {
 	strTime := lstTime[1]
 	lstTime = strings.Split(strTime, ` (`)
 	strTime = lstTime[0]
-	if err := сам.Секция.Уст(alias.Время(strTime)); err != nil { // Возможно уже всё
+	if err := сам.ОбратВремяУст(alias.Время(strTime)); err != nil { // Возможно уже всё
 		// log._rintf("WARN BattleWait.Wait(): при установке времени ожидания сражения(%v)\n\terr=%v\n", strTime, err)
 		return ""
 	}

server/serv_bots/warbot/angar/death_match/death_net/death_net.go

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