d08 Переход на однопотоный интерфейс

pkg/arena/arena.go

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

pkg/types/iangar.go

@@ -7,10 +7,8 @@ package types
 // ИАнгар -- интерфейс ангара
 type ИАнгар interface {
 	ИСценаСтр
-	// Пуск -- запускает ангар в работу
-	Пуск() error
 	// Конвой -- возвращает объект конвоя
-	Конвой() Конвой
+	Конвой() ИКонвой
 	// Золото -- возвращает объект золота
 	Золото() ИСтатПарам
 	// Топливо -- возвращает объект топлива
@@ -33,8 +31,10 @@ type ИАнгар interface {
 	База() ИБаза
 	// Миссии -- возвращает объект миссий
 	Миссии() ИМиссии
-	// РесурсыОбновить -- принудитеьно обновляет ресурсы бота
+	// РесурсыОбновить -- принудительно обновляет ресурсы бота
 	РесурсыОбновить()
 	// Обновить -- требует обновления ангара
 	Обновить()
+	// Пуск -- запускает ангар в работу
+	Пуск()
 }

pkg/types/iarena.go

@@ -13,4 +13,8 @@ type ИАрена interface {
 	СтрОбновить(lstString []string) error
 	// ОбратВремяУст -- устанавливает новое значение обратного счётчика времени
 	ОбратВремяУст(времяСек alias.Время) error
+	// Обновить -- обновляет список строк арены
+	Обновить()
+	// Пуск -- запускает арену в обработку на текущий шаг
+	Пуск()
 }

pkg/types/iconvoy.go

@@ -5,7 +5,7 @@ package types
 */
 
 // Конвой -- интерфейс к объекту конвоя
-type Конвой interface {
+type ИКонвой interface {
 	ИСценаСтр
 	// Слава -- возвращает объект славы конвоя
 	Слава() ИСтатПарам

server/serv_bots/warbot/angar/angar.go

@@ -7,6 +7,7 @@ import (
 	"strings"
 	"sync"
 	"time"
+	"wartank/pkg/alias"
 	"wartank/pkg/arena"
 	"wartank/pkg/components/arena_net"
 	"wartank/pkg/types"
@@ -33,8 +34,8 @@ type Ангар struct {
 	сеть       types.ИАренаСеть
 	топливоБой *fuel_attack.ТопливоБой
 
-	бот      types.ИБот
-	конвой   *convoy.Конвой
+	бот types.ИБот
+	// конвой   *convoy.Конвой
 	сражение *battle.Сражение
 	битва    *masters.БитваМастеров
 	база     *base.База
@@ -52,6 +53,7 @@ type Ангар struct {
 	сетьТанкСтат *netstat.NetStat
 	танкПарам    *tank_params.ТанкПараметры
 	блок         sync.Mutex
+	словАрена    map[alias.АренаИмя]types.ИАрена
 }
 
 // НовАнгар -- возвращает новый *Angar
@@ -60,8 +62,8 @@ func НовАнгар(бот types.ИБот) (*Ангар, error) {
 	if ош != nil {
 		return nil, fmt.Errorf("НовАнгар(): при создании параметров танка, ош=\n\t%w", ош)
 	}
+
 	сам := &Ангар{
-		ИАрена:        arena.НовАрена(бот, "Ангар", `<title>Ангар</title>`),
 		слог:          бот.Сервер().Слог(),
 		бот:           бот,
 		золото:        static_param.НовСтатПарам("gold"),
@@ -71,7 +73,15 @@ func НовАнгар(бот types.ИБот) (*Ангар, error) {
 		сереброВсего:  static_param.НовСтатПарам("silver_all"),
 		silverOnline:  static_param.НовСтатПарам("silver_online"),
 		танкПарам:     танкПарам,
+		словАрена:     make(map[alias.АренаИмя]types.ИАрена),
+	}
+	аренаКонф := arena.АренаКонфиг{
+		Бот_:         бот,
+		АренаИмя_:    "Ангар",
+		СтрКонтроль_: "<title>Ангар</title>",
+		ФнПуск_:      сам.пуск,
 	}
+	сам.ИАрена = arena.НовАрена(аренаКонф)
 	сам.сеть = arena_net.НовАренаСеть(сам, "https://wartank.ru/angar")
 	var err error
 	{ // Сеть атаки
@@ -86,8 +96,8 @@ func НовАнгар(бот types.ИБот) (*Ангар, error) {
 			return nil, fmt.Errorf("НовАнгар(): in create NetResource, err=\n\t%w", err)
 		}
 	}
-	// Convoy
-	сам.конвой = convoy.НовКонвой(сам.бот)
+	конвой := convoy.НовКонвой(сам.бот)
+	сам.словАрена["конвой"] = конвой
 	// Сражение
 	сам.сражение = battle.НовСражение(сам.бот)
 	{ // Битва мастеров
@@ -116,7 +126,7 @@ func НовАнгар(бот types.ИБот) (*Ангар, error) {
 	return сам, nil
 }
 
-// Обновить -- обновить ангар принудиельно
+// Обновить -- обновить ангар принудительно
 func (сам *Ангар) Обновить() {
 	сам.РесурсыОбновить()
 	ош := сам.сетьТанкСтат.Update()
@@ -125,28 +135,17 @@ func (сам *Ангар) Обновить() {
 		сам.бот.Сервер().Отменить()
 		return
 	}
-	сам.конвой.Обновить()
+	сам.словАрена["конвой"].Пуск()
 	сам.топливо.Обновить()
 }
 
-// запускает обработку ангара
-func (сам *Ангар) Пуск() error {
+// Запускает обработку ангара
+func (сам *Ангар) пуск() {
 	{ // Запуск компонентов
-		if err := сам.топливоБой.Пуск(); err != nil {
-			return fmt.Errorf("Ангар.Пуск(): при пуске сетевой секции опыт за топливо, err=\n\t%w", err)
-		}
-		if err := сам.конвой.Пуск(); err != nil {
-			return fmt.Errorf("Ангар.Пуск(): при пуске конвоя, err=\n\t%w", err)
-		}
-		if err := сам.сражение.Пуск(); err != nil {
-			return fmt.Errorf("Ангар.Пуск(): при пуске сражения, err=\n\t%w", err)
-		}
-		if err := сам.битва.Run(); err != nil {
-			return fmt.Errorf("Ангар.Пуск(): при пуске схватки, err=\n\t%w", err)
-		}
-		if err := сам.база.Пуск(); err != nil {
-			return fmt.Errorf("Ангар.Пуск(): при пуске базы, err=\n\t%w", err)
-		}
+		сам.топливоБой.Пуск()
+		сам.сражение.Пуск()
+		сам.битва.Пуск()
+		сам.база.Пуск()
 		сам.миссии.Пуск()
 		сам.танкПарам.Пуск()
 		go сам.топливо.Run()
@@ -184,7 +183,6 @@ func (сам *Ангар) Пуск() error {
 			}
 		}
 	}()
-	return nil
 }
 
 // Обновляет ресурсы ангара
@@ -205,8 +203,8 @@ func (сам *Ангар) Сражение() types.ИСражениеСцена
 }
 
 // Конвой -- возвращает объект конвоя
-func (сам *Ангар) Конвой() types.Конвой {
-	return сам.конвой
+func (сам *Ангар) Конвой() types.ИКонвой {
+	return сам.словАрена["конвой"].(types.ИКонвой)
 }
 
 // Золото -- возвращает объект золота
@@ -224,7 +222,7 @@ func (сам *Ангар) Уровень() types.ИСтатПарам {
 	return сам.уровень
 }
 
-// Прогресс -- возвращает прогрес уровня игрока
+// Прогресс -- возвращает прогресс уровня игрока
 func (сам *Ангар) Прогресс() types.ИСтатПарам {
 	return сам.progress
 }
@@ -244,13 +242,13 @@ func (сам *Ангар) СереброЗаработаноСессия() types
 	return сам.silverOnline
 }
 
-// СереброОбновить -- на основе фактического серебра -- обновляет вырабатанное серебро
+// СереброОбновить -- на основе фактического серебра -- обновляет выработанное серебро
 func (сам *Ангар) СереброОбновить(silverFact int) {
 	if сам.сереброВсего.Получ() == 0 { // Если запуск
 		сам.сереброВсего.Уст(silverFact)
 		return
 	}
-	if сам.сереброВсего.Получ() > silverFact { // Если потрачего серебро
+	if сам.сереброВсего.Получ() > silverFact { // Если потрачено серебро
 		сам.сереброВсего.Уст(silverFact)
 		return
 	}

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

@@ -47,11 +47,9 @@ type Арсенал struct {
 func НовАрсенал(база types.ИБаза) (types.ИАрсенал, error) {
 	лог := logger.НовЛоггер("Арсенал")
 	лог.Инфо("НовАрсенал()\n")
-	арена := arena.НовАрена(база.Бот(), "Арсенал", `<span class="green2">Ремкомплект</span><br/>`)
 
 	кнт, фнОтмена := context.WithCancel(база.Контекст())
 	сам := &Арсенал{
-		ИАрена:     арена,
 		бот:        база.Бот(),
 		база:       база,
 		фугас:      static_param.НовСтатПарам(стрФугасы),
@@ -65,9 +63,15 @@ func НовАрсенал(база types.ИБаза) (types.ИАрсенал, er
 
 		лог: лог,
 	}
+	аренаКонфиг := arena.АренаКонфиг{
+		Бот_:         база.Бот(),
+		АренаИмя_:    "Арсенал",
+		СтрКонтроль_: `<span class="green2">Ремкомплект</span><br/>`,
+		ФнПуск_:      сам.пуск,
+	}
+	сам.ИАрена = arena.НовАрена(аренаКонфиг)
 	сам.вЛог = web_log.НовВебЛог(true)
 	сам.сеть = arena_net.НовАренаСеть(сам, "https://wartank.ru/production/Armory")
-	// сам.сеть = arsenalnet.НовАрсеналСеть(сам)
 	go сам.пуск()
 	сам.вЛог.Добавить("НовАрсенал(): Арсенал создан")
 	return сам, nil
@@ -78,12 +82,12 @@ func (сам *Арсенал) Уровень() types.ИСтатПарам {
 	return сам.уровень
 }
 
-// ПродуктКолСейчас -- возвращает количество прозводимого продукта
+// ПродуктКолСейчас -- возвращает количество производимого продукта
 func (сам *Арсенал) ПродуктКолСейчас() int {
 	return сам.продуктКол.Получ()
 }
 
-// ПродуктИмяСейчас -- возвращает имя прозводимого продукта
+// ПродуктИмяСейчас -- возвращает имя производимого продукта
 func (сам *Арсенал) ПродуктИмяСейчас() string {
 	return сам.продуктИмя
 }
@@ -156,7 +160,7 @@ func (сам *Арсенал) проверитьПостроить() bool {
 	return true
 }
 
-// Обновляет текущий уровень оружейки (может быть не построена)
+// Обновляет текущий уровень арсенала (может быть не построена)
 func (сам *Арсенал) уровеньОбновить() bool {
 	сам.вЛог.Добавить("Арсенал.уровеньОбновить()\n")
 	списСтр, ош := сам.сеть.ВебВоркер().Получ("http://wartank.ru/buildings")
@@ -194,7 +198,7 @@ func (сам *Арсенал) уровеньОбновить() bool {
 	return true
 }
 
-// Строит оружейку при нулевом уровне
+// Строит арсенал при нулевом уровне
 func (сам *Арсенал) построить() (bool, error) {
 	сам.вЛог.Добавить("Арсенал.построить()\n")
 	списСтр, ош := сам.сеть.ВебВоркер().Получ("https://wartank.ru/building-upgrade/Armory")
@@ -219,15 +223,15 @@ func (сам *Арсенал) построить() (bool, error) {
 		return true, nil
 	}
 	// <a class="simple-but border mb5" href="Armory?30-1.ILinkListener-upgradeLink-link">
-	// Пробуем построить оружейку
+	// Пробуем построить арсенал
 	_стр := strings.TrimPrefix(стр, `<a class="simple-but border mb5" href="`)
 	_стр = strings.TrimSuffix(_стр, `">`)
 	ссылка := "https://wartank.ru/building-upgrade/" + _стр
 	// https://wartank.ru/building-upgrade/Armory?35-1.ILinkListener-upgradeLink-link
 	списСтр, ош = сам.сеть.ВебВоркер().Получ(ссылка)
 	if ош != nil {
-		сам.лог.Ошибка("построить(): при GET-команде 'построить оружейку', ош=\n\t%v\n", ош)
-		сам.вЛог.Добавить("ОШИБКА Арсенал.построить(): при GET-команде 'построить оружейку', err=\n\t%v\n", ош)
+		сам.лог.Ошибка("построить(): при GET-команде 'построить арсенал', ош=\n\t%v\n", ош)
+		сам.вЛог.Добавить("ОШИБКА Арсенал.построить(): при GET-команде 'построить арсенал', err=\n\t%v\n", ош)
 		return false, fmt.Errorf("")
 	}
 	еслиНайти = false
@@ -247,7 +251,7 @@ func (сам *Арсенал) построить() (bool, error) {
 	return true, nil
 }
 
-// Пытается проапгрейдить оружейку
+// Пытается проапгрейдить арсенал
 func (сам *Арсенал) проапгрейдить() bool {
 	сам.вЛог.Добавить("Арсенал.проапгрейдить()\n")
 	var (
@@ -260,7 +264,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 списСтр {
@@ -282,13 +286,13 @@ func (сам *Арсенал) проапгрейдить() bool {
 		ссылка := "https://wartank.ru/building-upgrade/" + _стр
 		списСтр, ош = сам.сеть.ВебВоркер().Получ(ссылка)
 		if ош != nil {
-			сам.вЛог.Добавить("ОШИБКА Арсенал.проапгрейдить().фнКупить(): при GET-команде 'купить постройку оружейки', err=\n\t%v\n", ош)
+			сам.вЛог.Добавить("ОШИБКА Арсенал.проапгрейдить().фнКупить(): при GET-команде 'купить постройку арсенала', err=\n\t%v\n", ош)
 			return false
 		}
 		// Проверить, что постройка состоялась
 		for _, стр := range списСтр {
 			if strings.Contains(стр, "ILinkListener-upgradeLink-link") {
-				log.Printf("Арсенал.проапгрейдить().фнКупить(): покупка оружейкине прошла\n\tlink=%v\n\tстр=\n\t%v\n", ссылка, стр)
+				log.Printf("Арсенал.проапгрейдить().фнКупить(): покупка арсенала не прошла\n\tlink=%v\n\tстр=\n\t%v\n", ссылка, стр)
 				return false // Покупка не оплачена
 			}
 		}
@@ -428,23 +432,23 @@ func (сам *Арсенал) СтатаОбновить() (err error) {
 		lstArsenal = сам.СписПолучить()
 	)
 	{ // Найти маркер фугасного снаряда
-		for _, strFugas := range lstArsenal {
-			if strings.Contains(strFugas, `<span class="nwr"><img class="rico vm" src="/images/shells/HighExplosive.png" alt="Фугасный снаряд" title="Фугасный снаряд"/> `) {
-				strOut = strFugas
+		for _, стрФугас := range lstArsenal {
+			if strings.Contains(стрФугас, `<span class="nwr"><img class="rico vm" src="/images/shells/HighExplosive.png" alt="Фугасный снаряд" title="Фугасный снаряд"/> `) {
+				strOut = стрФугас
 				break
 			}
 		}
-		lstFugas := strings.Split(strOut, `<span class="nwr"><img class="rico vm" src="/images/shells/HighExplosive.png" alt="Фугасный снаряд" title="Фугасный снаряд"/> `)
-		strFugas := lstFugas[1]
-		lstFugas = strings.Split(strFugas, ` &nbsp;&nbsp;</span>`)
-		strFugas = lstFugas[0]
-		iFugas, err := strconv.Atoi(strFugas)
+		списФугас := strings.Split(strOut, `<span class="nwr"><img class="rico vm" src="/images/shells/HighExplosive.png" alt="Фугасный снаряд" title="Фугасный снаряд"/> `)
+		стрФугас := списФугас[1]
+		списФугас = strings.Split(стрФугас, ` &nbsp;&nbsp;</span>`)
+		стрФугас = списФугас[0]
+		целФугас, err := strconv.Atoi(стрФугас)
 		if err != nil {
-			ош := fmt.Errorf("ОШИБКА Арсенал.СтатаОбновить(): fugas(%v) not number, err=\n\t%w", strFugas, err)
+			ош := fmt.Errorf("ОШИБКА Арсенал.СтатаОбновить(): фугас(%v) not number, err=\n\t%w", стрФугас, err)
 			сам.вЛог.Добавить("%v\n", ош)
 			return ош
 		}
-		сам.Фугасы().Уст(iFugas)
+		сам.Фугасы().Уст(целФугас)
 	}
 	{ // Найти маркер бронебойного снаряда
 		for _, strArmor := range lstArsenal {
@@ -467,38 +471,38 @@ func (сам *Арсенал) СтатаОбновить() (err error) {
 		сам.вЛог.Добавить("Арсенал.СтатаОбновить(): бронебойки=%v\n", iArmor)
 	}
 	{ // Найти маркер кумулятивного снаряда
-		for _, strKumul := range lstArsenal {
-			if strings.Contains(strKumul, `<span class="nwr"><img class="rico vm" src="/images/shells/HollowCharge.png" alt="Кумулятивный снаряд" title="Кумулятивный снаряд"/> `) {
-				strOut = strKumul
+		for _, стрКумул := range lstArsenal {
+			if strings.Contains(стрКумул, `<span class="nwr"><img class="rico vm" src="/images/shells/HollowCharge.png" alt="Кумулятивный снаряд" title="Кумулятивный снаряд"/> `) {
+				strOut = стрКумул
 				break
 			}
 		}
-		lstKumul := strings.Split(strOut, `<span class="nwr"><img class="rico vm" src="/images/shells/HollowCharge.png" alt="Кумулятивный снаряд" title="Кумулятивный снаряд"/> `)
-		strKumul := lstKumul[1]
-		lstKumul = strings.Split(strKumul, ` &nbsp;&nbsp;</span>`)
-		strKumul = lstKumul[0]
-		iKumul, err := strconv.Atoi(strKumul)
+		списКумул := strings.Split(strOut, `<span class="nwr"><img class="rico vm" src="/images/shells/HollowCharge.png" alt="Кумулятивный снаряд" title="Кумулятивный снаряд"/> `)
+		стрКумул := списКумул[1]
+		списКумул = strings.Split(стрКумул, ` &nbsp;&nbsp;</span>`)
+		стрКумул = списКумул[0]
+		целКумул, err := strconv.Atoi(стрКумул)
 		if err != nil {
-			return fmt.Errorf("Арсенал.СтатаОбновить(): kumul(%v) not number, err=\n\t%w", strKumul, err)
+			return fmt.Errorf("Арсенал.СтатаОбновить(): кумул(%v) not number, err=\n\t%w", стрКумул, err)
 		}
-		сам.Кумулятивы().Уст(iKumul)
+		сам.Кумулятивы().Уст(целКумул)
 	}
 	{ // Найти маркер ремкомплекта
-		for ind, strRemka := range lstArsenal {
-			if strings.Contains(strRemka, `<span class="nwr"><img class="rico vm" src="/images/shells/repairkit.gif"/> `) {
+		for ind, стрРемка := range lstArsenal {
+			if strings.Contains(стрРемка, `<span class="nwr"><img class="rico vm" src="/images/shells/repairkit.gif"/> `) {
 				strOut = lstArsenal[ind]
 				break
 			}
 		}
-		lstRemka := strings.Split(strOut, `<span class="nwr"><img class="rico vm" src="/images/shells/repairkit.gif"/> `)
-		strRemka := lstRemka[1]
-		lstRemka = strings.Split(strRemka, `</span>`)
-		strRemka = lstRemka[0]
-		iRemka, err := strconv.Atoi(strRemka)
+		списРемка := strings.Split(strOut, `<span class="nwr"><img class="rico vm" src="/images/shells/repairkit.gif"/> `)
+		стрРемка := списРемка[1]
+		списРемка = strings.Split(стрРемка, `</span>`)
+		стрРемка = списРемка[0]
+		целРемка, err := strconv.Atoi(стрРемка)
 		if err != nil {
-			return fmt.Errorf("Арсенал.СтатаОбновить(): remka(%v) not number, err=\n\t%w", strRemka, err)
+			return fmt.Errorf("Арсенал.СтатаОбновить(): ремка(%v) not number, err=\n\t%w", стрРемка, err)
 		}
-		сам.Ремки().Уст(iRemka)
+		сам.Ремки().Уст(целРемка)
 	}
 	return nil
 }
@@ -606,13 +610,13 @@ func (сам *Арсенал) сделатьКумули() bool {
 		return false
 	}
 	// Получить ссылку на кумулятив
-	lstKumul := strings.Split(стрВых, `<a class="simple-but border" href="`)
-	strLink := lstKumul[1]
-	lstKumul = strings.Split(strLink, `"><span><span>Начать производство</span></span></a>`)
-	strLink = "https://wartank.ru/production/" + lstKumul[0]
+	списКумул := strings.Split(стрВых, `<a class="simple-but border" href="`)
+	strLink := списКумул[1]
+	списКумул = strings.Split(strLink, `"><span><span>Начать производство</span></span></a>`)
+	strLink = "https://wartank.ru/production/" + списКумул[0]
 	time.Sleep(time.Millisecond * 50)
 	if _, err := сам.сеть.Get(strLink); err != nil {
-		// log._rintf("ERRO ArsenalNet.makeKumul(): in make product arsenal kumul , err=\n\t%v\n", err)
+		// log._rintf("ERRO ArsenalNet.makeКумуль(): in make product arsenal кумуль , err=\n\t%v\n", err)
 		return false
 	}
 	сам.АренаСостояние().СостояниеУст(стрКумулятивы)
@@ -622,19 +626,19 @@ func (сам *Арсенал) сделатьКумули() bool {
 // Создать фугасы
 func (сам *Арсенал) сделатьФугасы() bool {
 	var (
-		lstArsenal = сам.СписПолучить()
-		стрВых     string
-		еслиНадено bool
-		инд        int
+		lstArsenal  = сам.СписПолучить()
+		стрВых      string
+		еслиНайдено bool
+		инд         int
 	)
 
 	for инд, стрВых = range lstArsenal {
 		if strings.Contains(стрВых, `<span class="green2">Фугасный снаряд</span><br/>`) {
-			еслиНадено = true
+			еслиНайдено = true
 			break
 		}
 	}
-	if !еслиНадено {
+	if !еслиНайдено {
 		return false
 	}
 	стрВых = lstArsenal[инд+10]
@@ -642,23 +646,23 @@ func (сам *Арсенал) сделатьФугасы() bool {
 		return false
 	}
 	// Получить ссылку на ремку
-	lstKumul := strings.Split(стрВых, `<a class="simple-but border" href="`)
-	strLink := lstKumul[1]
-	lstKumul = strings.Split(strLink, `"><span><span>Начать производство</span></span></a>`)
-	strLink = "https://wartank.ru/production/" + lstKumul[0]
+	списКумул := strings.Split(стрВых, `<a class="simple-but border" href="`)
+	strLink := списКумул[1]
+	списКумул = strings.Split(strLink, `"><span><span>Начать производство</span></span></a>`)
+	strLink = "https://wartank.ru/production/" + списКумул[0]
 	time.Sleep(time.Millisecond * 50)
 	if _, err := сам.сеть.Get(strLink); err != nil {
-		// log._rintf("ERRO ArsenalNet.makeFugas(): in make request arsenal product, err=\n\t%v\n", err)
+		// log._rintf("ERRO ArsenalNet.makeФугас(): in make request arsenal product, err=\n\t%v\n", err)
 		return false
 	}
 	сам.АренаСостояние().СостояниеУст(стрФугасы)
-	// log._rintf("INFO Арсенал.makeFugas()\n")
+	// log._rintf("INFO Арсенал.makeФугас()\n")
 	return true
 }
 
 // Создать ремку. Выполняется если подходят условия
 func (сам *Арсенал) сделатьРемку() bool {
-	// _mt.Println("\tArsenalNet.makeRemka()")
+	// _mt.Println("\tArsenalNet.makeРемка()")
 	var (
 		стрВых      string
 		еслиНайдено bool
@@ -666,7 +670,7 @@ func (сам *Арсенал) сделатьРемку() bool {
 	)
 	lstArsenal, ош := сам.сеть.ВебВоркер().Получ("https://wartank.ru/production/Armory")
 	if ош != nil {
-		log.Printf("Арсенал.сделатьРемку(): при получении страницы оружейки, err=\n\t%v\n", ош)
+		log.Printf("Арсенал.сделатьРемку(): при получении страницы арсенала, err=\n\t%v\n", ош)
 		return false
 	}
 	// <span class="green2">Ремкомплект</span><br/>

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

@@ -10,7 +10,7 @@ import (
 	"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/bank_mode"
 	"wartank/server/serv_bots/warbot/tank_stat/static_param"
 )
 
@@ -23,20 +23,25 @@ type Банк struct {
 	types.ИАрена
 	сеть       types.ИАренаСеть
 	сереброБот types.ИСтатПарам
-	режим1     *bankmode.BankMode // 1 режим работы на выбор
-	режим2     *bankmode.BankMode // 2 режим работы на выбор
+	режим1     *bank_mode.BankMode // 1 режим работы на выбор
+	режим2     *bank_mode.BankMode // 2 режим работы на выбор
 }
 
 // НовБанк -- возвращает новый *Bank
 func НовБанк(база types.ИБаза) (*Банк, error) {
-	арена := arena.НовАрена(база.Бот(), "Банк", `<span class="green2">Серебро</span><br/>`)
 
 	сам := &Банк{
-		ИАрена:     арена,
 		сереброБот: static_param.НовСтатПарам("silver_bot"),
-		режим1:     bankmode.NewBankMode(),
-		режим2:     bankmode.NewBankMode(),
+		режим1:     bank_mode.NewBankMode(),
+		режим2:     bank_mode.NewBankMode(),
 	}
+	аренаКонфиг := arena.АренаКонфиг{
+		Бот_:         база.Бот(),
+		АренаИмя_:    "Банк",
+		СтрКонтроль_: `<span class="green2">Серебро</span><br/>`,
+		ФнПуск_:      сам.пуск,
+	}
+	сам.ИАрена = arena.НовАрена(аренаКонфиг)
 	сам.сеть = arena_net.НовАренаСеть(сам, "https://wartank.ru/production/Bank")
 	return сам, nil
 }
@@ -228,7 +233,7 @@ func (сам *Банк) построитьУлучшить() bool {
 			return false
 		}
 	}
-	log.Printf("Банк.построитьПровер(): построен упешно\n")
+	log.Printf("Банк.построитьПровер(): построен успешно\n")
 	return true
 }
 

server/serv_bots/warbot/angar/base/bank/bankmode/bankmode.go → server/serv_bots/warbot/angar/base/bank/bank_mode/bank_mode.go

@@ -1,4 +1,4 @@
-package bankmode
+package bank_mode
 
 import (
 	"wartank/pkg/types"

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

@@ -29,7 +29,6 @@ import (
 const (
 	времОжидПлат    = "01:00" // Время ожидания платного ускорения
 	времОжидБесплат = "30:00" // Время ожидания бесплатного ускорения
-
 )
 
 // База -- объект базы
@@ -50,12 +49,17 @@ type База struct {
 
 // НовБаза -- возвращает новую базу бота
 func НовБаза(ангар types.ИАнгар) (*База, error) {
-	арена := arena.НовАрена(ангар.Бот(), "База", `<title>База</title>`)
-	log.Printf("НовБаза(): %q\n", арена.Бот().Имя())
+	log.Printf("НовБаза(): %q\n", ангар.Бот().Имя())
 	сам := &База{
-		ИАрена: арена,
-		бот:    ангар.Бот(),
+		бот: ангар.Бот(),
+	}
+	аренаКонфиг := arena.АренаКонфиг{
+		Бот_:         ангар.Бот(),
+		АренаИмя_:    "База",
+		СтрКонтроль_: `<title>База</title>`,
+		ФнПуск_:      сам.пуск,
 	}
+	сам.ИАрена = arena.НовАрена(аренаКонфиг)
 	strUrl := "https://wartank.ru/buildings"
 	сам.сеть = arena_net.НовАренаСеть(сам, strUrl)
 	var ош error
@@ -96,13 +100,12 @@ func НовБаза(ангар types.ИАнгар) (*База, error) {
 }
 
 // Запускает базу в обработку
-func (сам *База) Пуск() error {
+func (сам *База) Пуск() {
 	log.Printf("Base.Run()\n")
 	if err := сам.runComponent(); err != nil {
-		return fmt.Errorf("Base.Run(): run, err=\n\t%w", err)
+		panic(fmt.Errorf("Base.Run(): run, err=\n\t%w", err))
 	}
 	go сам.пуск()
-	return nil
 }
 
 // Собственная работа
@@ -269,16 +272,16 @@ func (сам *База) шахтаСтатаОбновить() {
 			}
 		}
 		if еслиНайдено && strings.Contains(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/ore.png?2" alt="Руда" title="Руда"/> `) {
-			lstRuda := strings.Split(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/ore.png?2" alt="Руда" title="Руда"/> `)
-			strRuda := lstRuda[1]
-			lstRuda = strings.Split(strRuda, ` &nbsp;&nbsp;</span>`)
-			strRuda = lstRuda[0]
-			iRuda, err := strconv.Atoi(strRuda)
+			списРуда := strings.Split(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/ore.png?2" alt="Руда" title="Руда"/> `)
+			стрРуда := списРуда[1]
+			списРуда = strings.Split(стрРуда, ` &nbsp;&nbsp;</span>`)
+			стрРуда = списРуда[0]
+			целРуда, err := strconv.Atoi(стрРуда)
 			if err != nil {
-				log.Printf("ERRO Base.checkMineStat(): руда(%v) не число, err=\n\t%v\n", strRuda, err)
+				log.Printf("ERRO Base.checkMineStat(): руда(%v) не число, err=\n\t%v\n", стрРуда, err)
 				return
 			}
-			сам.шахта.Руда().Уст(iRuda)
+			сам.шахта.Руда().Уст(целРуда)
 		}
 	}
 	{ // Ищем железо
@@ -723,7 +726,7 @@ func (сам *База) checkBankForce() {
 			сам.банк.АренаСостояние().РаботаИмяУст("")
 			сам.банк.АренаСостояние().СостояниеУст(cons.РежимАпгрейд)
 			if err := сам.банк.ОбратВремяУст(времОжидБесплат); err != nil {
-				log.Printf("WARN Base.checkBankForce(): при установке времени бесплатного ускорения агрейда банка(%v)\n\terr=%v\n", времОжидБесплат, err)
+				log.Printf("WARN Base.checkBankForce(): при установке времени бесплатного ускорения апгрейда банка(%v)\n\terr=%v\n", времОжидБесплат, err)
 			}
 		}
 	}

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

@@ -28,10 +28,8 @@ type СкладТоплива struct {
 
 // НовТопливо -- возвращает новой склад топлива
 func НовСкладТоплива(база types.ИБаза) (*СкладТоплива, error) {
-	секция := arena.НовАрена(база.Бот(), "Склад_топлива", `<span class="green2">Склад топлива - `)
 	кнт, фнОтмена := context.WithCancel(база.Контекст())
 	сам := &СкладТоплива{
-		ИАрена:   секция,
 		бот:      база.Бот(),
 		база:     база,
 		топливо:  static_param.НовСтатПарам("топливо"),
@@ -39,7 +37,13 @@ func НовСкладТоплива(база types.ИБаза) (*СкладТо
 		фнОтмена: фнОтмена,
 		уровень:  static_param.НовСтатПарам("уровень"),
 	}
-
+	аренаКонфиг := arena.АренаКонфиг{
+		Бот_:         база.Бот(),
+		АренаИмя_:    "Склад_топлива",
+		СтрКонтроль_: `<span class="green2">Склад топлива - `,
+		ФнПуск_:      сам.пуск,
+	}
+	сам.ИАрена = arena.НовАрена(аренаКонфиг)
 	сам.сеть = arena_net.НовАренаСеть(сам, "https://wartank.ru/fuelStore")
 	_ = types.ИБазаТопливо(сам)
 	return сам, nil
@@ -370,7 +374,7 @@ func (сам *СкладТоплива) Уровень() types.ИСтатПар
 	return сам.уровень
 }
 
-// Тоаливо -- возвращает топливо
+// Топливо -- возвращает топливо
 func (сам *СкладТоплива) Топливо() types.ИСтатПарам {
 	return сам.топливо
 }

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

@@ -23,12 +23,17 @@ type Рынок struct {
 
 // НовРынок -- возвращает новый рынок
 func НовРынок(база types.ИБаза) *Рынок {
-	арена := arena.НовАрена(база.Бот(), "Рынок", `<title>Рынок</title>`)
 	сам := &Рынок{
-		ИАрена:  арена,
 		бот:     база.Бот(),
 		уровень: static_param.НовСтатПарам("уровень"),
 	}
+	аренаКонфиг := arena.АренаКонфиг{
+		Бот_:         база.Бот(),
+		АренаИмя_:    "Рынок",
+		СтрКонтроль_: `<title>Рынок</title>`,
+		ФнПуск_:      сам.пуск,
+	}
+	сам.ИАрена = arena.НовАрена(аренаКонфиг)
 	сам.сеть = arena_net.НовАренаСеть(сам, "https://wartank.ru/market")
 	return сам
 }
@@ -405,7 +410,7 @@ func (сам *Рынок) купитьЗолото() bool {
 	case "10", "50", "100", "500": // Допустимые суммы трат
 		еслиКупить = true
 	case "1000": // Если стоит тысяча серебра
-		if серебро > 500_000 { // Если серебра больше полумиллона -- покупаем
+		if серебро > 500_000 { // Если серебра больше полумиллиона -- покупаем
 			еслиКупить = true
 		}
 	case "5000", "10000": // Если большая сумма -- можно купить и больше

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

@@ -35,11 +35,8 @@ type Шахта struct {
 
 // НовШахта -- возвращает новый *Mine
 func НовШахта(база types.ИБаза) (types.ИБазаШахта, error) {
-	арена := arena.НовАрена(база.Бот(), "Шахта", `<span class="green2">Руда</span><br/>`)
-
 	кнт, фнОтмена := context.WithCancel(база.Контекст())
 	сам := &Шахта{
-		ИАрена:     арена,
 		бот:        база.Бот(),
 		база:       база,
 		руда:       static_param.НовСтатПарам("руда"),
@@ -50,9 +47,15 @@ func НовШахта(база types.ИБаза) (types.ИБазаШахта, er
 		уровень:    static_param.НовСтатПарам("уровень"),
 		кнт:        кнт,
 		фнОтмена:   фнОтмена,
-		лог:        арена.ВебЛог(),
 	}
-
+	аренаКонфиг := arena.АренаКонфиг{
+		Бот_:         сам.бот,
+		АренаИмя_:    "Шахта",
+		СтрКонтроль_: `<span class="green2">Руда</span><br/>`,
+		ФнПуск_:      сам.пуск,
+	}
+	сам.ИАрена = arena.НовАрена(аренаКонфиг)
+	сам.лог = сам.ВебЛог()
 	сам.сеть = arena_net.НовАренаСеть(сам, "https://wartank.ru/production/Mine")
 	go сам.пуск()
 	сам.лог.ОтклВывод()
@@ -554,12 +557,12 @@ func (сам *Шахта) Руда() types.ИСтатПарам {
 	return сам.руда
 }
 
-// ПродуктКолСейчас -- возвращает количество прозводимого продукта
+// ПродуктКолСейчас -- возвращает количество производимого продукта
 func (сам *Шахта) ПродуктКолСейчас() int {
 	return сам.продуктКол.Получ()
 }
 
-// ПродуктИмяСейчас -- возвращает имя прозводимого продукта
+// ПродуктИмяСейчас -- возвращает имя производимого продукта
 func (сам *Шахта) ПродуктИмяСейчас() string {
 	return сам.продуктИмя
 }

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

@@ -45,9 +45,7 @@ type Полигон struct {
 func НовПолигон(база types.ИБаза) *Полигон {
 	лог := logger.НовЛоггер("Полигон " + база.Бот().Имя())
 	лог.Инфо("НовПолигон(): бот=%s\n", база.Бот().Имя())
-	секция := arena.НовАрена(база.Бот(), "Полигон", `<title>Полигон</title>`)
 	сам := &Полигон{
-		ИАрена:        секция,
 		бот:           база.Бот(),
 		танкСтат:      база.Бот().Стата(),
 		продуктСейчас: safe_string.НовБезопСтрока(),
@@ -55,6 +53,13 @@ func НовПолигон(база types.ИБаза) *Полигон {
 		уровень:       static_param.НовСтатПарам("уровень полигона"),
 		лог:           лог,
 	}
+	аренаКонфиг := arena.АренаКонфиг{
+		Бот_:         база.Бот(),
+		АренаИмя_:    "Полигон",
+		СтрКонтроль_: `<span class="green2">Полигон</span><br/>`,
+		ФнПуск_:      сам.пуск,
+	}
+	сам.ИАрена = arena.НовАрена(аренаКонфиг)
 	сам.сеть = arena_net.НовАренаСеть(сам, "https://wartank.ru/polygon")
 	_ = types.ИБазаПолигон(сам)
 	return сам
@@ -155,7 +160,7 @@ func (сам *Полигон) построить() bool {
 		сам.лог.Ошибка("построить(): при обновлении страницы строительства полигона, ош=\n\t%v\n", ош)
 		return false
 	}
-	ссылка0 := "" // ссылкана постройку
+	ссылка0 := "" // ссылка на постройку
 
 	{ // Поиск ссылки на покупку
 		for _, стр := range списСтр {
@@ -218,7 +223,7 @@ func (сам *Полигон) построить() bool {
 		// https://wartank.ru/wicket/page?52-1.ILinkListener-confirmLink
 		ссылка2 = "http://wartank.ru/wicket/" + ссылка2
 		//ссылка2="https://wartank.ru/wicket/page?25-1.ILinkListener-confirmLink"
-		списСтр, ош = сам.сеть.ВебВоркер().Получ(ссылка2)
+		_, ош = сам.сеть.ВебВоркер().Получ(ссылка2)
 		if ош != nil {
 			сам.лог.Ошибка("построить(): при подтверждении покупки полигона, ош=\n\t%v\n", ош)
 			return false
@@ -230,8 +235,8 @@ func (сам *Полигон) построить() bool {
 // Проверяет уровень полигона
 func (сам *Полигон) уровеньПолучить() bool {
 	var (
-		стрВых     = ""
-		еслиНидено bool
+		стрВых      = ""
+		еслиНайдено bool
 	)
 	lstBase, err := сам.сеть.ВебВоркер().Получ("https://wartank.ru/buildings")
 	if err != nil {
@@ -241,11 +246,11 @@ func (сам *Полигон) уровеньПолучить() bool {
 	// <span class="green2">Полигон - 5</span><br/>
 	for _, стрВых = range lstBase {
 		if strings.Contains(стрВых, `<span class="green2">Полигон - `) {
-			еслиНидено = true
+			еслиНайдено = true
 			break
 		}
 	}
-	if !еслиНидено {
+	if !еслиНайдено {
 		return false
 	}
 	стрУровень := strings.TrimPrefix(стрВых, `<span class="green2">Полигон - `)
@@ -437,14 +442,14 @@ func (сам *Полигон) усилениеПровер() {
 // Выбирает самый слабый параметр и усиливает его
 func (сам *Полигон) усилениеДобавить() {
 	сам.сеть.Обновить()
-	// log._rintf("Polygon.checkPolygon(): при принудительном обновлении lstPlygon, mode=%s\terr=\n\t%v\n", сам.ModeCurrent().Get(), err)
+	// log._rintf("Polygon.checkPolygon(): при принудительном обновлении lstPolygon, 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 := сам.СписПолучить()
-	if len(lstPoligon) == 0 {
+	lstPolygon := сам.СписПолучить()
+	if len(lstPolygon) == 0 {
 		return
 	}
 	stat := сам.танкСтат
@@ -487,7 +492,7 @@ func (сам *Полигон) усилениеДобавить() {
 	)
 	switch strParam {
 	case стрАтака: // Усиливаем атаку
-		for ind, strOut = range lstPoligon {
+		for ind, strOut = range lstPolygon {
 			if strings.Contains(strOut, `>усиление атаки<`) {
 				еслиНайдено = true
 				break
@@ -497,7 +502,7 @@ func (сам *Полигон) усилениеДобавить() {
 			return
 		}
 		ind += 8
-		strOut = lstPoligon[ind]
+		strOut = lstPolygon[ind]
 		if strOut == "" {
 			return
 		}
@@ -510,7 +515,7 @@ func (сам *Полигон) усилениеДобавить() {
 			return
 		}
 		{ // Узнать на сколько форсирована атака
-			strForce := lstPoligon[ind-7]
+			strForce := lstPolygon[ind-7]
 			lstForce := strings.Split(strForce, `<span class="green2">+`)
 			strForce = lstForce[1]
 			lstForce = strings.Split(strForce, ` на `)
@@ -525,7 +530,7 @@ func (сам *Полигон) усилениеДобавить() {
 		}
 	case стрБроня: // Усиливаем броню
 		еслиНайдено = false
-		for ind, strOut = range lstPoligon {
+		for ind, strOut = range lstPolygon {
 			if strings.Contains(strOut, `>усиление брони<`) {
 				еслиНайдено = true
 				break
@@ -535,7 +540,7 @@ func (сам *Полигон) усилениеДобавить() {
 			return
 		}
 		ind += 8
-		strOut = lstPoligon[ind]
+		strOut = lstPolygon[ind]
 		if strOut == "" {
 			return
 		}
@@ -548,7 +553,7 @@ func (сам *Полигон) усилениеДобавить() {
 			return
 		}
 		{ // Узнать на сколько форсирована броня
-			strForce := lstPoligon[ind-7]
+			strForce := lstPolygon[ind-7]
 			lstForce := strings.Split(strForce, `<span class="green2">+`)
 			strForce = lstForce[1]
 			lstForce = strings.Split(strForce, ` на `)
@@ -563,7 +568,7 @@ func (сам *Полигон) усилениеДобавить() {
 		}
 	case стрТочность: // Усиливаем точность
 		еслиНайдено = false
-		for ind, strOut = range lstPoligon {
+		for ind, strOut = range lstPolygon {
 			if strings.Contains(strOut, `>улучшение точности<`) {
 				еслиНайдено = true
 				break
@@ -573,7 +578,7 @@ func (сам *Полигон) усилениеДобавить() {
 			return
 		}
 		ind += 8
-		strOut = lstPoligon[ind]
+		strOut = lstPolygon[ind]
 		if strOut == "" {
 			return
 		}
@@ -586,7 +591,7 @@ func (сам *Полигон) усилениеДобавить() {
 			return
 		}
 		{ // Узнать на сколько форсирована точность
-			strForce := lstPoligon[ind-7]
+			strForce := lstPolygon[ind-7]
 			lstForce := strings.Split(strForce, `<span class="green2">+`)
 			strForce = lstForce[1]
 			lstForce = strings.Split(strForce, ` на `)
@@ -601,7 +606,7 @@ func (сам *Полигон) усилениеДобавить() {
 		}
 	case стрПрочность: // Усиливаем мощность
 		еслиНайдено = false
-		for ind, strOut = range lstPoligon {
+		for ind, strOut = range lstPolygon {
 			if strings.Contains(strOut, `>увеличение прочности<`) {
 				еслиНайдено = true
 				break
@@ -611,7 +616,7 @@ func (сам *Полигон) усилениеДобавить() {
 			return
 		}
 		ind += 8
-		strOut = lstPoligon[ind]
+		strOut = lstPolygon[ind]
 		lstLink := strings.Split(strOut, `<a class="simple-but border" href="`)
 		strOut = lstLink[1]
 		lstLink = strings.Split(strOut, `"><span><span>Получить бесплатно</span></span></a>`)
@@ -621,7 +626,7 @@ func (сам *Полигон) усилениеДобавить() {
 			return
 		}
 		{ // Узнать на сколько форсирована прочность
-			strForce := lstPoligon[ind-7]
+			strForce := lstPolygon[ind-7]
 			lstForce := strings.Split(strForce, `<span class="green2">+`)
 			strForce = lstForce[1]
 			lstForce = strings.Split(strForce, ` на `)

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

@@ -12,25 +12,29 @@ import (
 
 // Сражение -- объект сражения
 type Сражение struct {
-	*arena.Арена
+	types.ИАрена
 	бот    types.ИБот
 	клиент types.ИХттпВоркер
 
 	регистрация *battle_register.СхваткаРегистрация // Регистратор на сражение
-	ожидание    *battle_wait.СхваткаОжидание        // Ождатель начала сражения
+	ожидание    *battle_wait.СхваткаОжидание        // Ожидатель начала сражения
 	действие    *battle_worker.СхваткаИсполнитель   // Исполнитель сражения
 
 }
 
 // НовСражение -- возвращает новый *Battle
 func НовСражение(бот types.ИБот) *Сражение {
-	секция := arena.НовАрена(бот, "Группа сражения", `<span>до начала `)
 	сам := &Сражение{
-		Арена:  секция,
 		бот:    бот,
 		клиент: бот.Сеть().ВебВоркер(),
 	}
-
+	аренаКонфиг:= arena.АренаКонфиг{
+		Бот_:         бот,
+		АренаИмя_:    "Группа сражения",
+		СтрКонтроль_: "<span>до начала ",
+		ФнПуск_:      сам.пуск,
+	}
+	сам.ИАрена = arena.НовАрена(аренаКонфиг)
 	сам.регистрация = battle_register.НовСражениеРегистрация(бот)
 	сам.ожидание = battle_wait.НовСражениеОжидание(бот)
 	сам.действие = battle_worker.НовСражениеИсполнитель(бот)
@@ -39,9 +43,8 @@ func НовСражение(бот types.ИБот) *Сражение {
 	return сам
 }
 
-func (сам *Сражение) Пуск() error {
+func (сам *Сражение) Пуск() {
 	go сам.пуск()
-	return nil
 }
 
 // запускает в работу сражение
@@ -53,7 +56,7 @@ func (сам *Сражение) пуск() {
 		default:
 			сам.регистрация.Зарегистрироваться()
 			сам.ожидание.Ожидать()
-			сам.действие.Танковать()
+			сам.действие.Пуск()
 			time.Sleep(time.Second * 2) // Пауза между циклами, чтобы сервер не долбить запросами
 		}
 	}

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

@@ -1,4 +1,4 @@
-// package battle_register -- регестрирует танк в битве
+// package battle_register -- регистрирует танк в битве
 package battle_register
 
 import (
@@ -20,21 +20,31 @@ type СхваткаРегистрация struct {
 
 // НовСражениеРегистрация -- возвращает новый ожидатель битвы
 func НовСражениеРегистрация(бот types.ИБот) *СхваткаРегистрация {
-	секция := arena.НовАрена(бот, "Сражение", `<title>Сражения</title>`)
 	сам := &СхваткаРегистрация{
-		ИАрена:       секция,
 		бот:          бот,
 		счётРегистер: 10_000,
 	}
+	аренаКонфиг := arena.АренаКонфиг{
+		Бот_:         бот,
+		АренаИмя_:    "Сражение",
+		СтрКонтроль_: `<title>Сражения</title>`,
+		ФнПуск_:      сам.пуск,
+	}
+	сам.ИАрена = arena.НовАрена(аренаКонфиг)
 	сам.сеть = arena_net.НовАренаСеть(сам, "https://wartank.ru/pve")
 	return сам
 }
 
+// Запускает в работу
+func (сам *СхваткаРегистрация) пуск() {
+
+}
+
 // Зарегистрироваться -- регистрирует танк на сражение
 func (сам *СхваткаРегистрация) Зарегистрироваться() {
 	// Найдено приглашение на участие
 	// https://wartank.ru/pve?{count}-1.ILinkListener-currentOverview-apply
-	фнРегис := func() []string {
+	фнГеис := func() []string {
 		стрСсылка := "https://wartank.ru/pve?0-1.ILinkListener-currentOverview-apply"
 		var стрКонтроль string //  "https://wartank.ru/pve?0-1.ILinkListener-currentOverview-apply"
 		for {
@@ -57,7 +67,7 @@ func (сам *СхваткаРегистрация) Зарегистрирова
 		}
 	}
 
-	if ош := сам.СтрОбновить(фнРегис()); ош != nil {
+	if ош := сам.СтрОбновить(фнГеис()); ош != nil {
 		log.Printf("СражениеРегистрация.Зарегистрироваться(): при обновлении lstBattle, err=\n\t%v\n", ош)
 	}
 	// log._rintf("INFO СражениеРегистрация.Зарегистрироваться(): регистрация прошла успешно\n")

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

@@ -19,15 +19,24 @@ type СхваткаОжидание struct {
 
 // НовСражениеОжидание -- возвращает новый ожидатель битвы
 func НовСражениеОжидание(бот types.ИБот) *СхваткаОжидание {
-	арена := arena.НовАрена(бот, "Ожидание сражения", `<title>Сражения</title>`)
 	сам := &СхваткаОжидание{
-		ИАрена: арена,
-		бот:    бот,
+		бот: бот,
 	}
+	аренаКонфиг := arena.АренаКонфиг{
+		Бот_:         бот,
+		АренаИмя_:    "Ожидание сражения",
+		СтрКонтроль_: `<title>Сражения</title>`,
+		ФнПуск_:      сам.пуск,
+	}
+	сам.ИАрена = arena.НовАрена(аренаКонфиг)
 	сам.сеть = arena_net.НовАренаСеть(сам, "https://wartank.ru/pve")
 	return сам
 }
 
+func (сам *СхваткаОжидание) пуск() {
+
+}
+
 // Ожидать -- ожидает начало сражения
 func (сам *СхваткаОжидание) Ожидать() {
 

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

@@ -6,8 +6,8 @@ import (
 	"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"
+	"wartank/server/serv_bots/warbot/angar/battle/battle_worker/battle_worker"
+	"wartank/server/serv_bots/warbot/angar/battle/battle_worker/battle_worker/battle_sound"
 	"wartank/server/serv_bots/warbot/tank_stat/static_param"
 )
 
@@ -20,27 +20,32 @@ type СхваткаИсполнитель struct {
 	еслиНачало types.ИСтатПарам
 
 	// Непосредственное сражение
-	действие *battleon.СражениеДействие
+	действие *battle_worker.СражениеДействие
 
-	sound *battlesound.BattleSound // Однопоточное проигрывание звука
+	sound *battle_sound.BattleSound // Однопоточное проигрывание звука
 }
 
 // НовСражениеДействие -- возвращает новый исполнитель битвы
 func НовСражениеИсполнитель(bot types.ИБот) *СхваткаИсполнитель {
-	section := arena.НовАрена(bot, "Ход сражения", `<title>Сражения</title>`)
 	сам := &СхваткаИсполнитель{
-		ИАрена:     section,
 		бот:        bot,
 		еслиНачало: static_param.НовСтатПарам("alarm"),
-		sound:      battlesound.NewBattleSound(),
+		sound:      battle_sound.NewBattleSound(),
 	}
+	аренаКонфиг := arena.АренаКонфиг{
+		Бот_:         bot,
+		АренаИмя_:    "Ход сражения",
+		СтрКонтроль_: `<title>Сражения</title>`,
+		ФнПуск_:      сам.пуск,
+	}
+	сам.ИАрена = arena.НовАрена(аренаКонфиг)
 	сам.сеть = arena_net.НовАренаСеть(сам, "https://wartank.ru/pve")
 	return сам
 }
 
-// Танковать -- выполняет битву
-func (сам *СхваткаИсполнитель) Танковать() {
-	сам.действие = battleon.НовСражениеДействие(сам.бот) // IBattleOn (онлайн)
+// выполняет битву
+func (сам *СхваткаИсполнитель) пуск() {
+	сам.действие = battle_worker.НовСражениеДействие(сам.бот) // IBattleOn (онлайн)
 	сам.sound.Play()
 	time.Sleep(time.Second * 10) // Задержка для звука на странице
 	<-сам.действие.Контекст().Done()

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

@@ -0,0 +1,47 @@
+package battle_sound
+
+import (
+	"time"
+	"wartank/pkg/components/sound"
+	"wartank/server/serv_bots/warbot/angar/battle/battle_worker/battle_worker/battle_sound/is_sound_play"
+)
+
+/*
+	Выполняет контроль за запуском одной озвучки битвы
+*/
+// BattleSound -- контроль одного раза запуска звука битвы
+type BattleSound struct {
+	isPlay *is_sound_play.IsPlay
+}
+
+// NewBattleSound -- возвращает новый  *BattleSound
+func NewBattleSound() *BattleSound {
+	return &BattleSound{
+		isPlay: is_sound_play.NewIsPlay(),
+	}
+}
+
+// Play -- играет музончик, если можно
+func (сам *BattleSound) Play() {
+	if сам.isPlay.Get() {
+		return
+	}
+	go сам.play()
+}
+
+// Проигрывает экслюзивно в отдельном потоке звук
+func (сам *BattleSound) play() {
+	сам.isPlay.Set()
+	val := 7
+	for val > 0 {
+		sound.Battle()
+		val--
+		time.Sleep(time.Second * 1)
+	}
+	val = 600 // Пауза для блокировки повторного включения начатой битвы
+	for val >= 0 {
+		val--
+		time.Sleep(time.Second * 1)
+	}
+	сам.isPlay.Reset()
+}

server/serv_bots/warbot/angar/death_match/death_worker/death_on/battlesound/isplay/isplay.go → server/serv_bots/warbot/angar/battle/battle_worker/battle_worker/battle_sound/is_sound_play/is_sound_play.go

@@ -1,4 +1,4 @@
-package isplay
+package is_sound_play
 
 import (
 	"sync"

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

@@ -0,0 +1,111 @@
+package battle_worker
+
+import (
+	"context"
+	"time"
+	"wartank/pkg/arena"
+	"wartank/pkg/components/arena_net"
+	"wartank/pkg/types"
+	"wartank/server/serv_bots/warbot/angar/battle/battle_worker/battle_worker/health"
+	"wartank/server/serv_bots/warbot/angar/battle/battle_worker/battle_worker/manevr"
+	"wartank/server/serv_bots/warbot/angar/battle/battle_worker/battle_worker/shot"
+	"wartank/server/serv_bots/warbot/angar/battle/battle_worker/battle_worker/shot/is_shot"
+)
+
+/*
+	Предоставляет сетевой компонент при непосредственном сражении
+*/
+
+// СражениеДействие -- непосредственно танкует в сражении
+type СражениеДействие struct {
+	types.ИАрена
+	сеть       types.ИАренаСеть
+	бот        types.ИБот
+	кнт        context.Context // Контекст сражения
+	фнОтменить func()          // Функция отмены сражения
+
+	выстрел     *shot.Выстрел    // Объект выстрела
+	здоровье    *health.Здоровье // Текущее здоровье танка
+	манёвр      *manevr.Манёвр   // Возможность маневрирования
+	логин       string
+	еслиВыстрел *is_shot.IsShot // Признак необходимости маскирования (запрет стрельбы, когда слабое здоровье)
+}
+
+// НовСражениеДействие -- возвращает новый *BattleOn
+func НовСражениеДействие(бот types.ИБот) *СражениеДействие {
+	// Ограничить время сражения бота
+	кнтСражение, фнОтменить := context.WithTimeout(бот.Контекст(), time.Second*305)
+	сам := &СражениеДействие{
+		бот:         бот,
+		кнт:         кнтСражение,
+		фнОтменить:  фнОтменить,
+		логин:       бот.Имя(),
+		еслиВыстрел: is_shot.NewIsShot(),
+	}
+	аренаКонфиг := arena.АренаКонфиг{
+		Бот_:         сам.бот,
+		АренаИмя_:    "Исполнитель сражения",
+		СтрКонтроль_: `<title>Сражения</title>`,
+		ФнПуск_:      сам.пуск,
+	}
+	сам.ИАрена = arena.НовАрена(аренаКонфиг)
+	сам.сеть = arena_net.НовАренаСеть(сам, "https://wartank.ru/pve")
+	go сам.пуск()
+	_ = types.ИСражениеДействие(сам)
+	return сам
+}
+
+// запускает сражение
+func (сам *СражениеДействие) пуск() {
+	defer func() {
+		сам.фнОтменить()
+		// log._rintf("BattleOn.run(): сражение завершено\n")
+	}()
+	{ // Подготовка к сражению
+		var err error
+		сам.выстрел, err = shot.НовВыстрел(сам) // Объект выстрела
+		if err != nil {
+			// log._rintf("ERRO BattleOn.Run(): при создании выстрела танка, err=\n\t%v\n", err)
+			return
+		}
+		сам.здоровье, err = health.НовЗдоровье(сам)
+		if err != nil {
+			// log._rintf("ERRO BattleOn.Run(): при создании здоровья танка, err=\n\t%v\n", err)
+			return
+		}
+		сам.манёвр, err = manevr.НовМанёвр(сам)
+		if err != nil {
+			// log._rintf("ERRO BattleOn.Run(): при создании маневра танка, err=\n\t%v\n", err)
+			return
+		}
+	}
+	// Рабочий цикл сражения
+	<-сам.кнт.Done()
+}
+
+// Сеть -- возвращает сетевой компонент секции
+func (сам *СражениеДействие) Сеть() types.ИАренаСеть {
+	return сам.сеть
+}
+
+func (сам *СражениеДействие) МанёврНадоУст() {
+	if сам.манёвр == nil {
+		return
+	}
+	сам.манёвр.УстНадо()
+}
+
+// ВыстрелБлок -- признак запрета стрельбы при слабом здоровье
+func (сам *СражениеДействие) ВыстрелБлок() types.ИЕслиВыстрел {
+	return сам.еслиВыстрел
+}
+
+// Кнт -- возвращает контекст отмены сражения
+func (сам *СражениеДействие) Контекст() context.Context {
+	return сам.кнт
+}
+
+// ОтменитьДействие -- вызов функции отмены контекста сражения
+func (сам *СражениеДействие) Отменить() {
+	сам.фнОтменить()
+}

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

@@ -1,10 +1,9 @@
-package battlesound
+package battle_sound
 
 import (
 	"time"
-
 	"wartank/pkg/components/sound"
-	"wartank/server/serv_bots/warbot/angar/battle/battle_worker/battleon/battlesound/isplay"
+	"wartank/server/serv_bots/warbot/angar/battle/battle_worker/battle_worker/battle_sound/is_sound_play"
 )
 
 /*
@@ -13,13 +12,13 @@ import (
 
 // BattleSound -- контроль одного раза запуска звука битвы
 type BattleSound struct {
-	isPlay *isplay.IsPlay
+	isPlay *is_sound_play.IsPlay
 }
 
 // NewBattleSound -- возвращает новый  *BattleSound
 func NewBattleSound() *BattleSound {
 	return &BattleSound{
-		isPlay: isplay.NewIsPlay(),
+		isPlay: is_sound_play.NewIsPlay(),
 	}
 }
 
@@ -40,7 +39,7 @@ func (сам *BattleSound) play() {
 		val--
 		time.Sleep(time.Second * 1)
 	}
-	val = 600 // Пауза для блокировки повторного вкелючения начатой битвы
+	val = 600 // Пауза для блокировки повторного включения начатой битвы
 	for val >= 0 {
 		val--
 		time.Sleep(time.Second * 1)

server/serv_bots/warbot/angar/battle/battle_worker/battleon/health/repairtime/repairtime.go → server/serv_bots/warbot/angar/battle/battle_worker/battle_worker/health/repair_time/repair_time.go

@@ -1,4 +1,4 @@
-package repairtime
+package repair_time
 
 import (
 	"fmt"

server/serv_bots/warbot/angar/battle/battle_worker/battleon/manevr/ismanevr/ismanevr.go → server/serv_bots/warbot/angar/battle/battle_worker/battle_worker/manevr/is_manevr/is_manevr.go

@@ -1,4 +1,4 @@
-package ismanevr
+package is_manevr
 
 import (
 	"sync"

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

@@ -5,10 +5,8 @@ import (
 	"log"
 	"strings"
 	"time"
-
-	"wartank/server/serv_bots/warbot/angar/battle/battle_worker/battleon/health/repairtime"
-	"wartank/server/serv_bots/warbot/angar/battle/battle_worker/battleon/manevr/ismanevr"
-
+	"wartank/server/serv_bots/warbot/angar/battle/battle_worker/battle_worker/health/repair_time"
+	"wartank/server/serv_bots/warbot/angar/battle/battle_worker/battle_worker/manevr/is_manevr"
 	// "wartank/internal/components/sound"
 	"wartank/pkg/types"
 )
@@ -19,10 +17,10 @@ import (
 
 // Манёвр -- маневрирует после выстрела
 type Манёвр struct {
-	types.ИСражениеДействие                        // FIXME:
-	еслиМанёврНадо          *ismanevr.IsManevr     // Требование выполнить манёвр
-	времяЖдать              *repairtime.RepairTime // Время до востановления манёвра
-	chTick                  chan int               // Тики для поиска маневра
+	types.ИСражениеДействие                         // FIXME:
+	еслиМанёврНадо          *is_manevr.IsManevr     // Требование выполнить манёвр
+	времяЖдать              *repair_time.RepairTime // Время до восстановления манёвра
+	chTick                  chan int                // Тики для поиска маневра
 }
 
 // НовМанёвр -- возвращает новый *Manevr
@@ -34,8 +32,8 @@ func НовМанёвр(действие types.ИСражениеДействи
 	}
 	сам := &Манёвр{
 		ИСражениеДействие: действие,
-		еслиМанёврНадо:    ismanevr.NewIsManevr(),
-		времяЖдать:        repairtime.NewRepairTime(),
+		еслиМанёврНадо:    is_manevr.NewIsManevr(),
+		времяЖдать:        repair_time.NewRepairTime(),
 		chTick:            make(chan int, 1),
 	}
 	_ = сам.времяЖдать.Set("0") // При запуске боя есть возможность маневрировать

server/serv_bots/warbot/angar/death_match/death_worker/death_on/shot/isshot/isshot.go → server/serv_bots/warbot/angar/battle/battle_worker/battle_worker/shot/is_shot/is_shot.go

@@ -1,4 +1,4 @@
-package isshot
+package is_shot
 
 import (
 	"sync"

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

@@ -1,4 +1,4 @@
-package battleon
+package battle_worker
 
 import (
 	"context"
@@ -6,10 +6,10 @@ import (
 	"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"
-	"wartank/server/serv_bots/warbot/angar/battle/battle_worker/battleon/shot"
-	"wartank/server/serv_bots/warbot/angar/battle/battle_worker/battleon/shot/isshot"
+	"wartank/server/serv_bots/warbot/angar/battle/battle_worker/battle_worker/health"
+	"wartank/server/serv_bots/warbot/angar/battle/battle_worker/battle_worker/manevr"
+	"wartank/server/serv_bots/warbot/angar/battle/battle_worker/battle_worker/shot"
+	"wartank/server/serv_bots/warbot/angar/battle/battle_worker/battle_worker/shot/is_shot"
 )
 
 /*
@@ -28,22 +28,27 @@ type СражениеДействие struct {
 	здоровье    *health.Здоровье // Текущее здоровье танка
 	манёвр      *manevr.Манёвр   // Возможность маневрирования
 	логин       string
-	еслиВыстрел *isshot.IsShot // Признак необходимости маскирования (запрет стрельбы, когда слабое здоровье)
+	еслиВыстрел *is_shot.IsShot // Признак необходимости маскирования (запрет стрельбы, когда слабое здоровье)
 }
 
 // НовСражениеДействие -- возвращает новый *BattleOn
 func НовСражениеДействие(бот types.ИБот) *СражениеДействие {
-	секция := arena.НовАрена(бот, "Исполнитель сражения", `<title>Сражения</title>`)
 	// Ограничить время сражения бота
 	кнтСражение, фнОтменить := context.WithTimeout(бот.Контекст(), time.Second*305)
 	сам := &СражениеДействие{
-		ИАрена:      секция,
 		бот:         бот,
 		кнт:         кнтСражение,
 		фнОтменить:  фнОтменить,
 		логин:       бот.Имя(),
-		еслиВыстрел: isshot.NewIsShot(),
+		еслиВыстрел: is_shot.NewIsShot(),
 	}
+	аренаКонфиг:=arena.АренаКонфиг{
+		Бот_:         сам.бот,
+		АренаИмя_:    "Исполнитель сражения",
+		СтрКонтроль_: `<title>Сражения</title>`,
+		ФнПуск_:      сам.пуск,
+	}
+	сам.ИАрена=arena.НовАрена(аренаКонфиг)
 	сам.сеть = arena_net.НовАренаСеть(сам, "https://wartank.ru/pve")
 	go сам.пуск()
 	_ = types.ИСражениеДействие(сам)

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

@@ -27,22 +27,21 @@ type Конвой struct {
 
 // НовКонвой -- возвращает новый *Convoy
 func НовКонвой(бот types.ИБот) *Конвой {
-	арена := arena.НовАрена(бот, "Конвой", `<title>Конвой</title>`)
 	сам := &Конвой{
-		ИАрена: арена,
 		бот:    бот,
 		слава:  static_param.НовСтатПарам("glory"),
 	}
+	аренаКонфиг:=arena.АренаКонфиг{
+		Бот_:         сам.бот,
+		АренаИмя_:    "Конвой",
+		СтрКонтроль_: `<title>Конвой</title>`,
+		ФнПуск_:      сам.пуск,
+	}
+	сам.ИАрена = arena.НовАрена(аренаКонфиг)
 	сам.сеть = arena_net.НовАренаСеть(сам, "https://wartank.ru/convoy")
 	return сам
 }
 
-// Пуск -- запускает конвой в работу
-func (сам *Конвой) Пуск() error {
-	go сам.пуск()
-	return nil
-}
-
 // UpdateLst -- принудительно обновляет состояние конвоя
 func (сам *Конвой) UpdateLst() {
 	сам.сеть.Обновить()
@@ -349,7 +348,7 @@ func (сам *Конвой) проверитьМиссияРазведкаКон
 	ссылка := "https://wartank.ru/" + _ссылка
 	lstConvoy, err := сам.сеть.ВебВоркер().Получ(ссылка)
 	if err != nil {
-		log.Printf("Конвой.проверитьМиссияРазведкаКонвой(): при выполнени команды GET, err=\n\t%v\n", err)
+		log.Printf("Конвой.проверитьМиссияРазведкаКонвой(): при выполнении команды GET, err=\n\t%v\n", err)
 		return
 	}
 	if err := сам.СтрОбновить(lstConvoy); err != nil {
@@ -393,7 +392,7 @@ func (сам *Конвой) проверитьМиссияМастерРазве
 	strLink = "https://wartank.ru/" + lstLink[0]
 	lstConvoy, err := сам.сеть.Get(strLink)
 	if err != nil {
-		// log._rintf("ERRO Конвой.checkMaster(): при выполнени команды GET, err=\n\t%v\n", err)
+		// log._rintf("ERRO Конвой.checkMaster(): при выполнении команды GET, err=\n\t%v\n", err)
 		return
 	}
 	if err := сам.СтрОбновить(lstConvoy); err != nil {
@@ -428,7 +427,7 @@ func (сам *Конвой) проверитьМиссия6фрагов() {
 	ссылка := "https://wartank.ru/" + _ссылка
 	lstConvoy, ош := сам.сеть.ВебВоркер().Получ(ссылка)
 	if ош != nil {
-		log.Printf("Конвой.проверитьМиссия6фрагов(): при выполнени команды GET, err=\n\t%v\n", ош)
+		log.Printf("Конвой.проверитьМиссия6фрагов(): при выполнении команды GET, err=\n\t%v\n", ош)
 		return
 	}
 	if err := сам.СтрОбновить(lstConvoy); err != nil {

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

@@ -12,25 +12,29 @@ import (
 
 // Сражение -- объект схватки
 type Схватка struct {
-	*arena.Арена
+	types.ИАрена
 	бот    types.ИБот
 	клиент types.ИХттпВоркер
 
 	регистрация *battle_register.СхваткаРегистрация // Регистратор на сражение
-	ожидание    *battle_wait.СхваткаОжидание        // Ождатель начала схватки
+	ожидание    *battle_wait.СхваткаОжидание        // Ожидатель начала схватки
 	действие    *battle_worker.СхваткаИсполнитель   // Исполнитель схватки
 
 }
 
 // НовСражение -- возвращает новый *Battle
 func НовСхватка(бот types.ИБот) *Схватка {
-	секция := arena.НовАрена(бот, "Группа схватки", `<span>до начала `)
 	сам := &Схватка{
-		Арена:  секция,
 		бот:    бот,
 		клиент: бот.Сеть().ВебВоркер(),
 	}
-
+	аренаКонфиг := arena.АренаКонфиг{
+		Бот_:         бот,
+		АренаИмя_:    "Группа схватки",
+		СтрКонтроль_: `<span>до начала `,
+		ФнПуск_:      сам.пуск,
+	}
+	сам.ИАрена = arena.НовАрена(аренаКонфиг)
 	сам.регистрация = battle_register.НовСражениеРегистрация(бот)
 	сам.ожидание = battle_wait.НовСражениеОжидание(бот)
 	сам.действие = battle_worker.НовСражениеИсполнитель(бот)
@@ -52,7 +56,7 @@ func (сам *Схватка) пуск() {
 		default:
 			сам.регистрация.Зарегистрироваться()
 			сам.ожидание.Ожидать()
-			сам.действие.Танковать()
+			сам.действие.Пуск()
 			time.Sleep(time.Second * 2) // Пауза между циклами, чтобы сервер не долбить запросами
 		}
 	}

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

@@ -19,15 +19,25 @@ type СражениеОжидание struct {
 
 // НовСражениеОжидание -- возвращает новый ожидатель битвы
 func НовСражениеОжидание(бот types.ИБот) *СражениеОжидание {
-	арена := arena.НовАрена(бот, "Ожидание сражения", `<title>Сражения</title>`)
 	сам := &СражениеОжидание{
-		ИАрена: арена,
 		бот:    бот,
 	}
+	аренаКонфиг:=arena.АренаКонфиг{
+		Бот_:         бот,
+		АренаИмя_:    "Ожидание сражения",
+		СтрКонтроль_: `<title>Сражения</title>`,
+		ФнПуск_:      сам.пуск,
+	}
+	сам.ИАрена = arena.НовАрена(аренаКонфиг)
 	сам.сеть = arena_net.НовАренаСеть(сам, "https://wartank.ru/pve")
 	return сам
 }
 
+// выполняет работу сражения
+func (сам *СражениеОжидание) пуск() {
+	
+}
+
 // Ожидать -- ожидает начало сражения
 func (сам *СражениеОжидание) Ожидать() {
 

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

@@ -1,4 +1,4 @@
-// package death_register -- регестрирует танк в схватке
+// package death_register -- регистрирует танк в схватке
 package death_register
 
 import (
@@ -20,16 +20,25 @@ type СхваткаРегистрация struct {
 
 // НовСхваткаРегистрация -- возвращает новый ожидатель битвы
 func НовСхваткаРегистрация(бот types.ИБот) *СхваткаРегистрация {
-	секция := arena.НовАрена(бот, "Сражение", `<title>Сражения</title>`)
 	сам := &СхваткаРегистрация{
-		ИАрена:       секция,
 		бот:          бот,
 		счётРегистер: 10_000,
 	}
+	аренаКонфиг:=arena.АренаКонфиг{
+		Бот_:         бот,
+		АренаИмя_:    "Сражение",
+		СтрКонтроль_: `<title>Сражения</title>`,
+		ФнПуск_:      сам.пуск,
+	}
+	сам.ИАрена = arena.НовАрена(аренаКонфиг)
 	сам.сеть = arena_net.НовАренаСеть(сам, "https://wartank.ru/dm")
 	return сам
 }
 
+func (сам *СхваткаРегистрация) пуск() {
+
+}
+
 // Зарегистрироваться -- регистрирует танк на сражение
 func (сам *СхваткаРегистрация) Зарегистрироваться() {
 	// Найдено приглашение на участие

server/serv_bots/warbot/angar/death_match/death_worker/death_on/battle_sound/battle_sound.go

@@ -0,0 +1,48 @@
+package battle_sound
+
+import (
+	"time"
+	"wartank/pkg/components/sound"
+	"wartank/server/serv_bots/warbot/angar/battle/battle_worker/battle_worker/battle_sound/is_sound_play"
+)
+
+/*
+	Выполняет контроль за запуском одной озвучки битвы
+*/
+
+// BattleSound -- контроль одного раза запуска звука битвы
+type BattleSound struct {
+	isPlay *is_sound_play.IsPlay
+}
+
+// NewBattleSound -- возвращает новый  *BattleSound
+func NewBattleSound() *BattleSound {
+	return &BattleSound{
+		isPlay: is_sound_play.NewIsPlay(),
+	}
+}
+
+// Play -- играет музончик, если можно
+func (сам *BattleSound) Play() {
+	if сам.isPlay.Get() {
+		return
+	}
+	go сам.play()
+}
+
+// Проигрывает экслюзивно в отдельном потоке звук
+func (сам *BattleSound) play() {
+	сам.isPlay.Set()
+	val := 7
+	for val > 0 {
+		sound.Battle()
+		val--
+		time.Sleep(time.Second * 1)
+	}
+	val = 600 // Пауза для блокировки повторного включения начатой битвы
+	for val >= 0 {
+		val--
+		time.Sleep(time.Second * 1)
+	}
+	сам.isPlay.Reset()
+}

server/serv_bots/warbot/angar/division/divwar/divwaron/divwarsound/isplay/isplay.go → server/serv_bots/warbot/angar/death_match/death_worker/death_on/battle_sound/is_play/is_play.go

@@ -1,4 +1,4 @@
-package isplay
+package is_play
 
 import (
 	"sync"

server/serv_bots/warbot/angar/death_match/death_worker/death_on/battlesound/battlesound.go

@@ -1,10 +1,9 @@
-package battlesound
+package battle_sound
 
 import (
 	"time"
-
 	"wartank/pkg/components/sound"
-	"wartank/server/serv_bots/warbot/angar/battle/battle_worker/battleon/battlesound/isplay"
+	"wartank/server/serv_bots/warbot/angar/battle/battle_worker/battle_worker/battle_sound/is_sound_play"
 )
 
 /*
@@ -13,13 +12,13 @@ import (
 
 // BattleSound -- контроль одного раза запуска звука битвы
 type BattleSound struct {
-	isPlay *isplay.IsPlay
+	isPlay *is_sound_play.IsPlay
 }
 
 // NewBattleSound -- возвращает новый  *BattleSound
 func NewBattleSound() *BattleSound {
 	return &BattleSound{
-		isPlay: isplay.NewIsPlay(),
+		isPlay: is_sound_play.NewIsPlay(),
 	}
 }
 
@@ -40,7 +39,7 @@ func (сам *BattleSound) play() {
 		val--
 		time.Sleep(time.Second * 1)
 	}
-	val = 600 // Пауза для блокировки повторного вкелючения начатой битвы
+	val = 600 // Пауза для блокировки повторного включения начатой битвы
 	for val >= 0 {
 		val--
 		time.Sleep(time.Second * 1)

server/serv_bots/warbot/angar/death_match/death_worker/death_on/death_on.go

@@ -9,7 +9,7 @@ import (
 	"wartank/server/serv_bots/warbot/angar/death_match/death_worker/death_on/health"
 	"wartank/server/serv_bots/warbot/angar/death_match/death_worker/death_on/manevr"
 	"wartank/server/serv_bots/warbot/angar/death_match/death_worker/death_on/shot"
-	"wartank/server/serv_bots/warbot/angar/death_match/death_worker/death_on/shot/isshot"
+	"wartank/server/serv_bots/warbot/angar/death_match/death_worker/death_on/shot/is_shot"
 )
 
 /*
@@ -28,22 +28,27 @@ type СхваткаДействие struct {
 	здоровье    *health.Здоровье // Текущее здоровье танка
 	манёвр      *manevr.Манёвр   // Возможность маневрирования
 	логин       string
-	еслиВыстрел *isshot.IsShot // Признак необходимости маскирования (запрет стрельбы, когда слабое здоровье)
+	еслиВыстрел *is_shot.IsShot // Признак необходимости маскирования (запрет стрельбы, когда слабое здоровье)
 }
 
 // НовСхваткаДействие -- возвращает новый *СхваткаДействие
 func НовСхваткаДействие(бот types.ИБот) *СхваткаДействие {
-	секция := arena.НовАрена(бот, "Исполнитель схватки", `<title>Схватка</title>`)
 	// Ограничить время сражения бота
 	кнтСражение, фнОтменить := context.WithTimeout(бот.Контекст(), time.Second*305)
 	сам := &СхваткаДействие{
-		ИАрена:      секция,
 		бот:         бот,
 		кнт:         кнтСражение,
 		фнОтменить:  фнОтменить,
 		логин:       бот.Имя(),
-		еслиВыстрел: isshot.NewIsShot(),
+		еслиВыстрел: is_shot.NewIsShot(),
 	}
+	аренаКонфиг:=arena.АренаКонфиг{
+		Бот_:         сам.бот,
+		АренаИмя_:    "Исполнитель схватки",
+		СтрКонтроль_: `<title>Схватка</title>`,
+		ФнПуск_:      сам.пуск,
+	}
+	сам.ИАрена = arena.НовАрена(аренаКонфиг)
 	сам.сеть = arena_net.НовАренаСеть(сам, "https://wartank.ru/de")
 	go сам.пуск()
 	return сам

server/serv_bots/warbot/angar/death_match/death_worker/death_on/manevr/manevr.go

@@ -8,8 +8,8 @@ import (
 
 	"github.com/sirupsen/logrus"
 
-	"wartank/server/serv_bots/warbot/angar/battle/battle_worker/battleon/health/repairtime"
-	"wartank/server/serv_bots/warbot/angar/battle/battle_worker/battleon/manevr/ismanevr"
+	"wartank/server/serv_bots/warbot/angar/battle/battle_worker/battle_worker/health/repair_time"
+	"wartank/server/serv_bots/warbot/angar/battle/battle_worker/battle_worker/manevr/is_manevr"
 
 	// "wartank/internal/components/sound"
 	"wartank/pkg/types"
@@ -21,10 +21,10 @@ import (
 
 // Манёвр -- маневрирует после выстрела
 type Манёвр struct {
-	types.ИСражениеДействие                        // FIXME:
-	еслиМанёврНадо          *ismanevr.IsManevr     // Требование выполнить манёвр
-	времяЖдать              *repairtime.RepairTime // Время до востановления манёвра
-	chTick                  chan int               // Тики для поиска маневра
+	types.ИСражениеДействие                         // FIXME:
+	еслиМанёврНадо          *is_manevr.IsManevr     // Требование выполнить манёвр
+	времяЖдать              *repair_time.RepairTime // Время до востановления манёвра
+	chTick                  chan int                // Тики для поиска маневра
 }
 
 // НовМанёвр -- возвращает новый *Manevr
@@ -36,8 +36,8 @@ func НовМанёвр(действие types.ИСражениеДействи
 	}
 	сам := &Манёвр{
 		ИСражениеДействие: действие,
-		еслиМанёврНадо:    ismanevr.NewIsManevr(),
-		времяЖдать:        repairtime.NewRepairTime(),
+		еслиМанёврНадо:    is_manevr.NewIsManevr(),
+		времяЖдать:        repair_time.NewRepairTime(),
 		chTick:            make(chan int, 1),
 	}
 	_ = сам.времяЖдать.Set("0") // При запуске боя есть возможность маневрировать

server/serv_bots/warbot/angar/battle/battle_worker/battleon/shot/isshot/isshot.go → server/serv_bots/warbot/angar/death_match/death_worker/death_on/shot/is_shot/is_shot.go

@@ -1,4 +1,4 @@
-package isshot
+package is_shot
 
 import (
 	"sync"

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

@@ -7,7 +7,7 @@ import (
 	"wartank/pkg/components/arena_net"
 	"wartank/pkg/types"
 	"wartank/server/serv_bots/warbot/angar/death_match/death_worker/death_on"
-	"wartank/server/serv_bots/warbot/angar/death_match/death_worker/death_on/battlesound"
+	"wartank/server/serv_bots/warbot/angar/death_match/death_worker/death_on/battle_sound"
 	"wartank/server/serv_bots/warbot/tank_stat/static_param"
 )
 
@@ -22,22 +22,32 @@ type СхваткаИсполнитель struct {
 	// Непосредственное сражение
 	действие *death_on.СхваткаДействие
 
-	sound *battlesound.BattleSound // Однопоточное проигрывание звука
+	sound *battle_sound.BattleSound // Однопоточное проигрывание звука
 }
 
 // НовСражениеДействие -- возвращает новый исполнитель схватки
 func НовСхваткаИсполнитель(bot types.ИБот) *СхваткаИсполнитель {
-	арена := arena.НовАрена(bot, "Ход сражения", `<title>Сражения</title>`)
 	сам := &СхваткаИсполнитель{
-		ИАрена:     арена,
 		бот:        bot,
 		еслиНачало: static_param.НовСтатПарам("alarm"),
-		sound:      battlesound.NewBattleSound(),
+		sound:      battle_sound.NewBattleSound(),
 	}
+	аренаКонфиг := arena.АренаКонфиг{
+		Бот_:         bot,
+		АренаИмя_:    "Ход сражения",
+		СтрКонтроль_: `<title>Сражения</title>`,
+		ФнПуск_:      сам.пуск,
+	}
+	сам.ИАрена = arena.НовАрена(аренаКонфиг)
 	сам.сеть = arena_net.НовАренаСеть(сам, "https://wartank.ru/pve")
 	return сам
 }
 
+// пуск исполнителя схватки
+func (сам *СхваткаИсполнитель) пуск() {
+	сам.еслиНачало = static_param.НовСтатПарам("alarm")
+}
+
 // Танковать -- выполняет битву
 func (сам *СхваткаИсполнитель) Танковать() {
 	сам.действие = death_on.НовСхваткаДействие(сам.бот) // IBattleOn (онлайн)

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

@@ -0,0 +1,219 @@
+package div_war
+
+import (
+	"fmt"
+	"log"
+	"strings"
+	"sync"
+	"time"
+	"wartank/pkg/alias"
+	"wartank/pkg/arena"
+	"wartank/pkg/types"
+	"wartank/server/serv_bots/warbot/angar/division/div_war/div_war_net"
+	"wartank/server/serv_bots/warbot/angar/division/div_war/div_war_on"
+	"wartank/server/serv_bots/warbot/angar/division/div_war/div_war_on/div_war_sound"
+	"wartank/server/serv_bots/warbot/tank_stat/static_param"
+)
+
+/*
+	Объект ожидания битвы дивизий
+*/
+
+// DivWar -- объект ожидания битвы дивизий
+type DivWar struct {
+	types.ИАрена
+	bot   types.ИБот
+	alarm types.ИСтатПарам
+	net   *div_war_net.DivWarNet
+	conn  types.ИХттпВоркер
+
+	// Непосредственная битва
+	divOn *div_war_on.DivWarOn
+	login string // Для непосредственной битвы дивизий
+	block sync.Mutex
+
+	chDivWar chan int // Сигнал начала битвы дивизий
+
+	sound *div_war_sound.DivWarSound // Однопоточное проигрывание звука
+}
+
+// NewDivWar -- возвращает новый *DivWar
+func NewDivWar(bot types.ИБот) (*DivWar, error) {
+	if bot == nil {
+		return nil, fmt.Errorf("NewDivWar(): IBot == nil")
+	}
+	сам := &DivWar{
+		bot:      bot,
+		alarm:    static_param.НовСтатПарам("alarm"),
+		chDivWar: make(chan int, 1),
+		sound:    div_war_sound.NewDivWarSound(),
+		conn:     bot.Сеть().ВебВоркер(),
+		login:    "prospero tank",
+	}
+	аренаКонфиг := arena.АренаКонфиг{
+		Бот_:         bot,
+		АренаИмя_:    "Битва дивизий",
+		СтрКонтроль_: `<span>до начала `,
+		ФнПуск_:      сам.пуск,
+	}
+	сам.ИАрена = arena.НовАрена(аренаКонфиг)
+	// сам.shotTimeFull.Set(8000) // 8000 msec
+	var err error
+	{ // Net
+		сам.net, err = div_war_net.NewDivWarNet(bot)
+		if err != nil {
+			return nil, fmt.Errorf("NewDivWar(): при создании DivWarNet, err=\n\t%w", err)
+		}
+	}
+	go сам.run()
+	go сам.резервТик()
+	return сам, nil
+}
+
+// запускает в работу битву дивизий
+func (сам *DivWar) пуск() {
+}
+
+func (сам *DivWar) резервТик() {
+	for {
+		select {
+		case <-сам.bot.Контекст().Done():
+			return
+		default:
+			ct0 := сам.ВремяОстат().ПолучМилСек()
+			time.Sleep(time.Second * 7)
+			ct1 := сам.ВремяОстат().ПолучМилСек()
+			if ct1.Сек() != ct0.Сек() {
+				continue
+			}
+			if сам.divOn != nil {
+				continue
+			}
+			сам.chDivWar <- 1
+		}
+	}
+}
+
+// запускает в работу битву дивизий
+func (сам *DivWar) run() {
+	сам.chDivWar <- 1
+	for {
+		select {
+		case <-сам.bot.Контекст().Done():
+			return
+		case <-сам.ВремяОстат().КаналСиг(): // Время обновить данные по сражению
+			сам.findTimeCount()
+			сам.upDivWar()
+		case <-сам.chDivWar: // Сигнал к началу сражения
+			сам.block.Lock()
+			if сам.divOn != nil {
+				continue
+			}
+			сам.alarm.Уст(1)
+			сам.sound.Play()
+			go сам.DivWar()              // Запустить цикл непосредственного сражения
+			time.Sleep(time.Second * 10) // Задержка для звука на странице
+			сам.alarm.Уст(0)
+		}
+	}
+}
+
+// Ищет время до начала битвы дивизий
+func (сам *DivWar) findTimeCount() {
+	сам.net.Обновить()
+	var (
+		strOut      string
+		lstDivWar   = сам.СписПолучить()
+		еслиНайдено bool
+		ind         int
+	)
+	for ind, strOut = range lstDivWar {
+		if strings.Contains(strOut, `до начала: `) {
+			ind++
+			strOut = lstDivWar[ind]
+			еслиНайдено = true
+			break
+		}
+		if strings.Contains(strOut, `>ОБЫЧНЫЕ<`) { // Это уже битва
+			сам.chDivWar <- 1
+			return
+		}
+	}
+	if !еслиНайдено { // Битва дивизий уже идёт
+		сам.chDivWar <- 1
+		return
+	}
+	lstTime := strings.Split(strOut, `<span>`)
+	strTime := lstTime[1]
+	lstTime = strings.Split(strTime, `</span>`)
+	strTime = lstTime[0]
+	if err := сам.ОбратВремяУст(alias.Время(strTime)); err != nil {
+		// log._rintf("WARN DivWar.findTimeCount(): при установке времени ожидания битвы дивизий(%v)\n\terr=%v\n", strTime, err)
+		return
+	}
+}
+
+// При необходимости поднимает взвод в атаку, вызывается только если обнаружено приглашение (+)
+func (сам *DivWar) upDivWar() {
+	var (
+		strOut      string
+		lstDivWar   = сам.СписПолучить()
+		еслиНайдено bool
+	)
+	for _, strOut = range lstDivWar {
+		if strings.Contains(strOut, `>Взвод, подъем! В атаку!<`) {
+			еслиНайдено = true
+			break
+		}
+		if strings.Contains(strOut, `<div class="white medium cntr bold mb5">Вы в рядах участников</div>`) {
+			// log._rintf("INFO DivWar.upDivWar(): уже зарегистрирован\n")
+			return
+		}
+	}
+	if !еслиНайдено {
+		return
+	}
+	// Найдено приглашение на участие
+	lstUp := strings.Split(strOut, `<a class="simple-but border" href="`)
+	linkUp := lstUp[1]
+	lstUp = strings.Split(linkUp, `"><span><span>Взвод, подъем! В атаку!</span></span></a>`)
+	linkUp = "https://wartank.ru/" + lstUp[0]
+	lstDivWar, err := сам.net.Get(linkUp)
+	if err != nil {
+		// log._rintf("ERRO DivWar.upDivWar(): при выполнении GET-команды на подъём в атаку, err=\n\t%v\n", err)
+		return
+	}
+	if err = сам.СтрОбновить(lstDivWar); err != nil {
+		log.Printf("DivWar.upDivWar(): при обновлении lstDivWar, err=\n\t%v\n", err)
+	}
+	// log._rintf("INFO DivWar.upDivWar(): регистрация прошла успешно\n")
+}
+
+// Ведёт сражение
+func (сам *DivWar) DivWar() {
+	defer func() {
+		сам.divOn = nil
+		сам.block.Unlock()
+		if err := сам.ОбратВремяУст("01"); err != nil {
+			panic(fmt.Errorf("DivWar.DivWar(): при установке CountDown, err=\n\t%w", err))
+		}
+		// log.Printf("INFO DivWar.DivWar(): сражение завершено\n")
+	}()
+	var err error
+	сам.divOn, err = div_war_on.NewDivWarOn(сам.bot) // IDivWarOn (онлайн)
+	if err != nil {
+		// log._rintf("ERRO DivWar.DivWarOn(): при создании IDivWarOn, err=\n\t%v\n", err)
+		time.Sleep(time.Millisecond * 250)
+		return
+	}
+	// Цикл ожидания окончания сражения
+	for !сам.divOn.ЕслиКонец().Получ() {
+		time.Sleep(time.Second * 1)
+	}
+
+}
+
+// Alarm -- возвращает признак начала сражения (для браузера)
+func (сам *DivWar) Alarm() types.ИСтатПарам {
+	return сам.alarm
+}

server/serv_bots/warbot/angar/division/div_war/div_war_net/div_war_net.go

@@ -0,0 +1,30 @@
+package div_war_net
+
+import (
+	"fmt"
+	"wartank/pkg/components/arena_net"
+	"wartank/pkg/types"
+)
+
+/*
+	Автоматически воюет в сражении
+*/
+
+// DivWarNet -- танкует в сражении
+type DivWarNet struct {
+	*arena_net.АренаСеть
+	bot types.ИБот
+}
+
+// NewDivWarNet -- возвращает новый *DivWarNet
+func NewDivWarNet(bot types.ИБот) (*DivWarNet, error) {
+	if bot == nil {
+		return nil, fmt.Errorf("NewDivWarNet(): IServBpt == nil")
+	}
+
+	сам := &DivWarNet{
+		// SectionNet: section_net.NewSectionNet(server, bot, ..., "https://wartank.ru/bitva"),
+		bot: bot,
+	}
+	return сам, nil
+}

server/serv_bots/warbot/angar/division/div_war/div_war_on/div_war_on.go

@@ -0,0 +1,183 @@
+package div_war_on
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"time"
+	"wartank/pkg/arena"
+	"wartank/pkg/components/arena_net"
+	"wartank/pkg/components/safe_bool"
+	"wartank/pkg/types"
+	"wartank/server/serv_bots/warbot/angar/division/div_war/div_war_on/health"
+	"wartank/server/serv_bots/warbot/angar/division/div_war/div_war_on/manevr"
+	"wartank/server/serv_bots/warbot/angar/division/div_war/div_war_on/shot"
+)
+
+/*
+	Предоставляет сетевой компонент при непосредственном сражении
+*/
+
+// DivWarOn -- непосредственно танкует в сражении
+type DivWarOn struct {
+	types.ИАрена
+	bot            types.ИБот
+	сеть           types.ИАренаСеть
+	ctxDivWar      context.Context // Контекст сражения
+	fnCancelDivWar func()          // Функция отмены сражения
+
+	shot      *shot.Shot     // Объект выстрела
+	health    *health.Health // Текущее здоровье танка
+	manevr    *manevr.Manevr // Возможность маневрирования
+	login     string
+	isMasking *safe_bool.БезопБул // Признак необходимости маскирования (запрет стрельбы, когда слабое здоровье)
+	chTick    chan int            // Ежесекундная проверка на окончание сражения
+	isEnd     *safe_bool.БезопБул
+}
+
+// NewDivWarOn -- возвращает новый *DivWarOn
+func NewDivWarOn(bot types.ИБот) (*DivWarOn, error) {
+	if bot == nil {
+		return nil, fmt.Errorf("NewDivWarOn(): IBot == nil")
+	}
+	ctxDivWar, fnCancelDivWar := context.WithTimeout(bot.Контекст(), time.Second*305)
+	сам := &DivWarOn{
+		bot:            bot,
+		ctxDivWar:      ctxDivWar,
+		fnCancelDivWar: fnCancelDivWar,
+		login:          bot.Имя(),
+		isMasking:      safe_bool.НовБезопБул(),
+		isEnd:          safe_bool.НовБезопБул(),
+	}
+	аренаКонфиг := arena.АренаКонфиг{
+		Бот_:         bot,
+		АренаИмя_:    "Сражение",
+		СтрКонтроль_: `<title>Сражения</title>`,
+		ФнПуск_:      сам.пуск,
+	}
+	сам.ИАрена = arena.НовАрена(аренаКонфиг)
+	сам.сеть = arena_net.НовАренаСеть(сам, "https://wartank.ru/pve")
+	if сам.checkEnd() {
+		return nil, fmt.Errorf("NewDivWarOn(): нет страницы для сражения")
+	}
+	go сам.makeTick()
+	go сам.run()
+	return сам, nil
+}
+
+// пускает сражение
+func (сам *DivWarOn) пуск() {
+}
+
+// Ежесекудный тик
+func (сам *DivWarOn) makeTick() {
+	defer func() {
+		close(сам.chTick)
+		сам.isEnd.Уст()
+	}()
+	for !сам.isEnd.Получ() {
+		select {
+		case <-сам.bot.Контекст().Done(): // Отмена контекста приложения
+			return
+		case <-сам.ctxDivWar.Done(): // Битва закончилась
+			return
+		default:
+			if сам.isEnd.Получ() {
+				return
+			}
+			сам.chTick <- 1
+			time.Sleep(time.Second * 1)
+		}
+	}
+}
+
+// запускает сражение
+func (сам *DivWarOn) run() {
+	// defer log._rintf("DivWarOn.run(): сражение завершено\n")
+	{ // Подготовка к сражению
+		var err error
+		сам.shot, err = shot.NewShot(сам, сам.login) // Объект выстрела
+		if err != nil {
+			// log._rintf("ERRO DivWarOn.Run(): при создании выстрела танка, err=\n\t%v\n", err)
+			return
+		}
+		сам.health, err = health.NewHealth(сам, сам.shot.IsEnd(), сам.login)
+		if err != nil {
+			// log._rintf("ERRO DivWarOn.Run(): при создании здоровья танка, err=\n\t%v\n", err)
+			сам.shot.IsEnd().Сброс()
+			return
+		}
+		сам.manevr, err = manevr.NewManevr(сам, сам.shot.IsEnd())
+		if err != nil {
+			// log._rintf("ERRO DivWarOn.Run(): при создании маневра танка, err=\n\t%v\n", err)
+			сам.shot.IsEnd().Сброс()
+			return
+		}
+	}
+	for { // Рабочий цикл сражения
+		select {
+		case <-сам.ctxDivWar.Done():
+			return
+		case <-сам.ВремяОстат().КаналСиг():
+			if сам.checkEnd() {
+				return
+			}
+		}
+	}
+}
+
+// Сеть -- возвращает сетевой компонент секции
+func (сам *DivWarOn) Сеть() types.ИАренаСеть {
+	return сам.сеть
+}
+
+// Проверяет окончание сражения
+func (сам *DivWarOn) checkEnd() bool {
+	defer func() {
+		if сам.isEnd.Получ() {
+			сам.fnCancelDivWar()
+			// log._rintf("DivWarOn.checkEnd(): сражение завершено\n")
+		}
+	}()
+
+	сам.сеть.Обновить()
+	lstDivWarOn := сам.СписПолучить()
+	for _, strOut := range lstDivWarOn {
+		if strings.Contains(strOut, `" class="simple-but gray"><span><span>ОБЫЧНЫЕ</span></span></a>`) {
+			сам.isEnd.Сброс()
+			return false
+		}
+	}
+	сам.isEnd.Уст()
+	сам.fnCancelDivWar()
+	return true
+}
+
+// ЕслиКонец -- возвращает признак окончания сражения (интерфейс)
+func (сам *DivWarOn) ЕслиКонец() *safe_bool.БезопБул {
+	return сам.isEnd
+}
+
+func (сам *DivWarOn) Манёвр() {
+	if сам.manevr == nil {
+		return
+	}
+	if сам.manevr.IsReady() {
+		сам.manevr.Manevr()
+	}
+}
+
+// ВыстрелБлок -- признак запрета стрельбы при слабом здоровье
+func (сам *DivWarOn) ВыстрелБлок() *safe_bool.БезопБул {
+	return сам.isMasking
+}
+
+// Ctx -- возвращает контекст отмены сражения
+func (сам *DivWarOn) Ctx() context.Context {
+	return сам.ctxDivWar
+}
+
+// CancelBattle - -вызов функции отмены контекста сражения
+func (сам *DivWarOn) CancelBattle() {
+	сам.fnCancelDivWar()
+}

server/serv_bots/warbot/angar/division/div_war/div_war_on/div_war_sound/div_war_sound.go

@@ -0,0 +1,48 @@
+package div_war_sound
+
+import (
+	"time"
+	"wartank/pkg/components/sound"
+	"wartank/server/serv_bots/warbot/angar/battle/battle_worker/battle_worker/battle_sound/is_sound_play"
+)
+
+/*
+	Выполняет контроль за запуском одной озвучки битвы
+*/
+
+// DivWarSound -- контроль одного раза запуска звука битвы
+type DivWarSound struct {
+	isPlay *is_sound_play.IsPlay
+}
+
+// NewDivWarSound -- возвращает новый  *DivWarSound
+func NewDivWarSound() *DivWarSound {
+	return &DivWarSound{
+		isPlay: is_sound_play.NewIsPlay(),
+	}
+}
+
+// Play -- играет музончик, если можно
+func (сам *DivWarSound) Play() {
+	if сам.isPlay.Get() {
+		return
+	}
+	go сам.play()
+}
+
+// Проигрывает экслюзивно в отдельном потоке звук
+func (сам *DivWarSound) play() {
+	сам.isPlay.Set()
+	val := 7
+	for val > 0 {
+		sound.DivWar()
+		val--
+		time.Sleep(time.Second * 1)
+	}
+	val = 600 // Пауза для блокировки повторного включения начатой битвы
+	for val >= 0 {
+		val--
+		time.Sleep(time.Second * 1)
+	}
+	сам.isPlay.Reset()
+}

server/serv_bots/warbot/angar/division/divwar/divwaron/divwarsound/divwarsound.go → server/serv_bots/warbot/angar/division/div_war/div_war_on/divwarsound/divwarsound.go

@@ -1,10 +1,9 @@
-package divwarsound
+package div_war_sound
 
 import (
 	"time"
-
 	"wartank/pkg/components/sound"
-	"wartank/server/serv_bots/warbot/angar/battle/battle_worker/battleon/battlesound/isplay"
+	"wartank/server/serv_bots/warbot/angar/battle/battle_worker/battle_worker/battle_sound/is_sound_play"
 )
 
 /*
@@ -13,13 +12,13 @@ import (
 
 // DivWarSound -- контроль одного раза запуска звука битвы
 type DivWarSound struct {
-	isPlay *isplay.IsPlay
+	isPlay *is_sound_play.IsPlay
 }
 
 // NewDivWarSound -- возвращает новый  *DivWarSound
 func NewDivWarSound() *DivWarSound {
 	return &DivWarSound{
-		isPlay: isplay.NewIsPlay(),
+		isPlay: is_sound_play.NewIsPlay(),
 	}
 }
 
@@ -40,7 +39,7 @@ func (сам *DivWarSound) play() {
 		val--
 		time.Sleep(time.Second * 1)
 	}
-	val = 600 // Пауза для блокировки повторного вкелючения начатой битвы
+	val = 600 // Пауза для блокировки повторного включения начатой битвы
 	for val >= 0 {
 		val--
 		time.Sleep(time.Second * 1)

server/serv_bots/warbot/angar/division/divwar/divwaron/health/health.go → server/serv_bots/warbot/angar/division/div_war/div_war_on/health/health.go

@@ -3,15 +3,12 @@ package health
 import (
 	"context"
 	"fmt"
-
 	// "log"
 	// "strconv"
 	"strings"
 	"time"
-
-	"wartank/server/serv_bots/warbot/angar/division/divwar/divwaron/health/healthtime"
-	"wartank/server/serv_bots/warbot/angar/division/divwar/divwaron/health/repairtime"
-
+	"wartank/server/serv_bots/warbot/angar/division/div_war/div_war_on/health/health_time"
+	"wartank/server/serv_bots/warbot/angar/division/div_war/div_war_on/health/repair_time"
 	// "wartank/internal/components/sound"
 	"wartank/pkg/components/safe_bool"
 	"wartank/pkg/types"
@@ -25,23 +22,23 @@ import (
 type Health struct {
 	types.ИДивизияВойнаДействие // FIXME:
 	fnCancel                    func()
-	temp                        *healthtime.HealthTime // Изменяемое здоровье танка
-	full                        *healthtime.HealthTime // Полное здоровье танка
-	isRepair                    *safe_bool.БезопБул    // Необходимость восстановления
-	repairTime                  *repairtime.RepairTime // Время до восстановления
-	isEnd                       *safe_bool.БезопБул    // Ссылка на признак конца сражения
-	login                       string                 // Для поиска контрольных строк
-	chTick                      chan int               // Канал для ровной отправки тиков
+	temp                        *health_time.HealthTime // Изменяемое здоровье танка
+	full                        *health_time.HealthTime // Полное здоровье танка
+	isRepair                    *safe_bool.БезопБул     // Необходимость восстановления
+	repairTime                  *repair_time.RepairTime // Время до восстановления
+	isEnd                       *safe_bool.БезопБул     // Ссылка на признак конца сражения
+	login                       string                  // Для поиска контрольных строк
+	chTick                      chan int                // Канал для ровной отправки тиков
 	// deltaOld                    int                    // Старая дельта потери здоровья
 	// countLow                    int
-	ctxBattle context.Context // Конекст сражения
+	ctxBattle context.Context // Контекст сражения
 }
 
 // NewHealth -- возвращает новый *Health
-func NewHealth(divwar types.ИДивизияВойнаДействие, isEnd *safe_bool.БезопБул, login string) (*Health, error) {
+func NewHealth(дивВойна types.ИДивизияВойнаДействие, isEnd *safe_bool.БезопБул, login string) (*Health, error) {
 	{ // Предусловия
-		if divwar == nil {
-			return nil, fmt.Errorf("NewHealth(): battle is nil")
+		if дивВойна == nil {
+			return nil, fmt.Errorf("NewHealth(): дивВойна is nil")
 		}
 		if isEnd == nil {
 			return nil, fmt.Errorf("NewHealth(): isEnd is nil")
@@ -51,14 +48,14 @@ func NewHealth(divwar types.ИДивизияВойнаДействие, isEnd *s
 		}
 	}
 	сам := &Health{
-		ИДивизияВойнаДействие: divwar,
-		fnCancel:   divwar.CancelBattle,
-		ctxBattle:  divwar.Ctx(),
-		temp:       healthtime.NewHealthTime(),
-		full:       healthtime.NewHealthTime(),
+		ИДивизияВойнаДействие: дивВойна,
+		fnCancel:   дивВойна.CancelBattle,
+		ctxBattle:  дивВойна.Ctx(),
+		temp:       health_time.NewHealthTime(),
+		full:       health_time.NewHealthTime(),
 		isRepair:   safe_bool.НовБезопБул(),
-		repairTime: repairtime.NewRepairTime(),
-		isEnd:      divwar.ЕслиКонец(),
+		repairTime: repair_time.NewRepairTime(),
+		isEnd:      дивВойна.ЕслиКонец(),
 		login:      login,
 		chTick:     make(chan int, 2),
 	}
@@ -67,7 +64,7 @@ func NewHealth(divwar types.ИДивизияВойнаДействие, isEnd *s
 	return сам, nil
 }
 
-// Отправляе ттики с заданным равным интервалом
+// Отправляет тики с заданным равным интервалом
 func (сам *Health) makeTik() {
 	defer func() {
 		сам.CancelBattle()
@@ -199,7 +196,7 @@ func (сам *Health) findRepairTime() {
 	// }
 }
 
-// Восстановливает здоровье (~)
+// Восстанавливает здоровье (~)
 func (сам *Health) repair() {
 	var (
 		strOut            string

server/serv_bots/warbot/angar/division/divwar/divwaron/health/healthtime/healthtime.go → server/serv_bots/warbot/angar/division/div_war/div_war_on/health/health_time/health_time.go

@@ -1,4 +1,4 @@
-package healthtime
+package health_time
 
 import (
 	"sync"

server/serv_bots/warbot/angar/division/divwar/divwaron/health/repairtime/repairtime.go → server/serv_bots/warbot/angar/division/div_war/div_war_on/health/repair_time/repair_time.go

@@ -1,4 +1,4 @@
-package repairtime
+package repair_time
 
 import (
 	"fmt"

server/serv_bots/warbot/angar/division/divwar/divwaron/manevr/manevr.go → server/serv_bots/warbot/angar/division/div_war/div_war_on/manevr/manevr.go

@@ -10,8 +10,8 @@ import (
 
 	"github.com/sirupsen/logrus"
 
-	"wartank/server/serv_bots/warbot/angar/division/divwar/divwaron/health/repairtime"
-	"wartank/server/serv_bots/warbot/angar/division/divwar/divwaron/manevr/ismanevr"
+	"wartank/server/serv_bots/warbot/angar/division/div_war/div_war_on/health/repair_time"
+	"wartank/server/serv_bots/warbot/angar/division/div_war/div_war_on/manevr/ismanevr"
 
 	// "wartank/internal/components/sound"
 	"wartank/pkg/components/safe_bool"
@@ -27,9 +27,9 @@ type Manevr struct {
 	types.ИДивизияВойнаДействие // FIXME:
 	isEnd                       *safe_bool.БезопБул
 	ctxEnd                      context.Context
-	isManevr                    *ismanevr.IsManevr     // Возможность выполнить манёвр
-	manevrTime                  *repairtime.RepairTime // Время до востановления манёвра
-	chTick                      chan int               // Тики для поиска маневра
+	isManevr                    *ismanevr.IsManevr      // Возможность выполнить манёвр
+	manevrTime                  *repair_time.RepairTime // Время до востановления манёвра
+	chTick                      chan int                // Тики для поиска маневра
 }
 
 // NewManevr -- возвращает новый *Manevr
@@ -47,7 +47,7 @@ func NewManevr(divwar types.ИДивизияВойнаДействие, isDivWar
 		ctxEnd:     divwar.Ctx(),
 		isEnd:      isDivWar,
 		isManevr:   ismanevr.NewIsManevr(),
-		manevrTime: repairtime.NewRepairTime(),
+		manevrTime: repair_time.NewRepairTime(),
 		chTick:     make(chan int, 1),
 	}
 	_ = сам.manevrTime.Set("0") // При запуске боя есть возможность маневрировать

server/serv_bots/warbot/angar/division/divwar/divwaron/shot/shot.go → server/serv_bots/warbot/angar/division/div_war/div_war_on/shot/shot.go

@@ -3,12 +3,14 @@ package shot
 import (
 	"context"
 	"fmt"
+
 	// "log"
 	"strconv"
 	"strings"
 	"time"
-	"wartank/server/serv_bots/warbot/angar/division/divwar/divwaron/shot/damage"
-	"wartank/server/serv_bots/warbot/angar/division/divwar/divwaron/shottime"
+	"wartank/server/serv_bots/warbot/angar/division/div_war/div_war_on/shot/damage"
+	"wartank/server/serv_bots/warbot/angar/division/div_war/div_war_on/shot_time"
+
 	// "wartank/internal/components/sound"
 	"wartank/pkg/alias"
 	"wartank/pkg/components/safe_bool"
@@ -27,7 +29,7 @@ import (
 // Shot -- объект выстрела
 type Shot struct {
 	types.ИДивизияВойнаДействие                     // FIXME:
-	recharge                    *shottime.ShotTime  // Сколько времени нужно для полной перезарядки
+	recharge                    *shot_time.ShotTime // Сколько времени нужно для полной перезарядки
 	damage                      *damage.Damage      // Урон от выстрела с памятью
 	damageSum                   alias.Урон          // Суммарный урон
 	isEnd                       *safe_bool.БезопБул // Признак конца сражения
@@ -49,7 +51,7 @@ func NewShot(divWar types.ИДивизияВойнаДействие, login stri
 	сам := &Shot{
 		ИДивизияВойнаДействие: divWar,
 		ctxEnd:   divWar.Ctx(),
-		recharge: shottime.NewShotTime(),
+		recharge: shot_time.NewShotTime(),
 		damage:   damage.NewDamage(),
 		isEnd:    divWar.ЕслиКонец(),
 		login:    login,

server/serv_bots/warbot/angar/division/divwar/divwaron/shottime/shottime.go → server/serv_bots/warbot/angar/division/div_war/div_war_on/shot_time/shot_time.go

@@ -1,11 +1,10 @@
-package shottime
+package shot_time
 
 import (
 	"sync"
+	"wartank/pkg/alias"
 
 	"github.com/sirupsen/logrus"
-
-	"wartank/pkg/alias"
 )
 
 /*

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

@@ -0,0 +1,183 @@
+package div_war_on
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"time"
+	"wartank/pkg/arena"
+	"wartank/pkg/components/arena_net"
+	"wartank/pkg/components/safe_bool"
+	"wartank/pkg/types"
+	"wartank/server/serv_bots/warbot/angar/division/div_war/div_war_on/health"
+	"wartank/server/serv_bots/warbot/angar/division/div_war/div_war_on/manevr"
+	"wartank/server/serv_bots/warbot/angar/division/div_war/div_war_on/shot"
+)
+
+/*
+	Предоставляет сетевой компонент при непосредственном сражении
+*/
+
+// DivWarOn -- непосредственно танкует в сражении
+type DivWarOn struct {
+	types.ИАрена
+	bot            types.ИБот
+	сеть           types.ИАренаСеть
+	ctxDivWar      context.Context // Контекст сражения
+	fnCancelDivWar func()          // Функция отмены сражения
+
+	shot      *shot.Shot     // Объект выстрела
+	health    *health.Health // Текущее здоровье танка
+	manevr    *manevr.Manevr // Возможность маневрирования
+	login     string
+	isMasking *safe_bool.БезопБул // Признак необходимости маскирования (запрет стрельбы, когда слабое здоровье)
+	chTick    chan int            // Ежесекундная проверка на окончание сражения
+	isEnd     *safe_bool.БезопБул
+}
+
+// NewDivWarOn -- возвращает новый *DivWarOn
+func NewDivWarOn(bot types.ИБот) (*DivWarOn, error) {
+	if bot == nil {
+		return nil, fmt.Errorf("NewDivWarOn(): IBot == nil")
+	}
+	ctxDivWar, fnCancelDivWar := context.WithTimeout(bot.Контекст(), time.Second*305)
+	сам := &DivWarOn{
+		bot:            bot,
+		ctxDivWar:      ctxDivWar,
+		fnCancelDivWar: fnCancelDivWar,
+		login:          bot.Имя(),
+		isMasking:      safe_bool.НовБезопБул(),
+		isEnd:          safe_bool.НовБезопБул(),
+	}
+	аренаКонфиг:= arena.АренаКонфиг{
+		Бот_:         bot,
+		АренаИмя_:    "Сражение",
+		СтрКонтроль_: `<title>Сражения</title>`,
+		ФнПуск_:      сам.пуск,
+	}
+	сам.ИАрена = arena.НовАрена(аренаКонфиг)
+	сам.сеть = arena_net.НовАренаСеть(сам, "https://wartank.ru/pve")
+	if сам.checkEnd() {
+		return nil, fmt.Errorf("NewDivWarOn(): нет страницы для сражения")
+	}
+	go сам.makeTick()
+	go сам.run()
+	return сам, nil
+}
+
+// пускает сражение
+func (сам *DivWarOn) пуск() {
+}
+
+// Ежесекудный тик
+func (сам *DivWarOn) makeTick() {
+	defer func() {
+		close(сам.chTick)
+		сам.isEnd.Уст()
+	}()
+	for !сам.isEnd.Получ() {
+		select {
+		case <-сам.bot.Контекст().Done(): // Отмена контекста приложения
+			return
+		case <-сам.ctxDivWar.Done(): // Битва закончилась
+			return
+		default:
+			if сам.isEnd.Получ() {
+				return
+			}
+			сам.chTick <- 1
+			time.Sleep(time.Second * 1)
+		}
+	}
+}
+
+// запускает сражение
+func (сам *DivWarOn) run() {
+	// defer log._rintf("DivWarOn.run(): сражение завершено\n")
+	{ // Подготовка к сражению
+		var err error
+		сам.shot, err = shot.NewShot(сам, сам.login) // Объект выстрела
+		if err != nil {
+			// log._rintf("ERRO DivWarOn.Run(): при создании выстрела танка, err=\n\t%v\n", err)
+			return
+		}
+		сам.health, err = health.NewHealth(сам, сам.shot.IsEnd(), сам.login)
+		if err != nil {
+			// log._rintf("ERRO DivWarOn.Run(): при создании здоровья танка, err=\n\t%v\n", err)
+			сам.shot.IsEnd().Сброс()
+			return
+		}
+		сам.manevr, err = manevr.NewManevr(сам, сам.shot.IsEnd())
+		if err != nil {
+			// log._rintf("ERRO DivWarOn.Run(): при создании маневра танка, err=\n\t%v\n", err)
+			сам.shot.IsEnd().Сброс()
+			return
+		}
+	}
+	for { // Рабочий цикл сражения
+		select {
+		case <-сам.ctxDivWar.Done():
+			return
+		case <-сам.ВремяОстат().КаналСиг():
+			if сам.checkEnd() {
+				return
+			}
+		}
+	}
+}
+
+// Сеть -- возвращает сетевой компонент секции
+func (сам *DivWarOn) Сеть() types.ИАренаСеть {
+	return сам.сеть
+}
+
+// Проверяет окончание сражения
+func (сам *DivWarOn) checkEnd() bool {
+	defer func() {
+		if сам.isEnd.Получ() {
+			сам.fnCancelDivWar()
+			// log._rintf("DivWarOn.checkEnd(): сражение завершено\n")
+		}
+	}()
+
+	сам.сеть.Обновить()
+	lstDivWarOn := сам.СписПолучить()
+	for _, strOut := range lstDivWarOn {
+		if strings.Contains(strOut, `" class="simple-but gray"><span><span>ОБЫЧНЫЕ</span></span></a>`) {
+			сам.isEnd.Сброс()
+			return false
+		}
+	}
+	сам.isEnd.Уст()
+	сам.fnCancelDivWar()
+	return true
+}
+
+// ЕслиКонец -- возвращает признак окончания сражения (интерфейс)
+func (сам *DivWarOn) ЕслиКонец() *safe_bool.БезопБул {
+	return сам.isEnd
+}
+
+func (сам *DivWarOn) Манёвр() {
+	if сам.manevr == nil {
+		return
+	}
+	if сам.manevr.IsReady() {
+		сам.manevr.Manevr()
+	}
+}
+
+// ВыстрелБлок -- признак запрета стрельбы при слабом здоровье
+func (сам *DivWarOn) ВыстрелБлок() *safe_bool.БезопБул {
+	return сам.isMasking
+}
+
+// Ctx -- возвращает контекст отмены сражения
+func (сам *DivWarOn) Ctx() context.Context {
+	return сам.ctxDivWar
+}
+
+// CancelBattle - -вызов функции отмены контекста сражения
+func (сам *DivWarOn) CancelBattle() {
+	сам.fnCancelDivWar()
+}

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

@@ -0,0 +1,183 @@
+package div_war_on
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"time"
+	"wartank/pkg/arena"
+	"wartank/pkg/components/arena_net"
+	"wartank/pkg/components/safe_bool"
+	"wartank/pkg/types"
+	"wartank/server/serv_bots/warbot/angar/division/div_war/div_war_on/health"
+	"wartank/server/serv_bots/warbot/angar/division/div_war/div_war_on/manevr"
+	"wartank/server/serv_bots/warbot/angar/division/div_war/div_war_on/shot"
+)
+
+/*
+	Предоставляет сетевой компонент при непосредственном сражении
+*/
+
+// DivWarOn -- непосредственно танкует в сражении
+type DivWarOn struct {
+	types.ИАрена
+	bot            types.ИБот
+	сеть           types.ИАренаСеть
+	ctxDivWar      context.Context // Контекст сражения
+	fnCancelDivWar func()          // Функция отмены сражения
+
+	shot      *shot.Shot     // Объект выстрела
+	health    *health.Health // Текущее здоровье танка
+	manevr    *manevr.Manevr // Возможность маневрирования
+	login     string
+	isMasking *safe_bool.БезопБул // Признак необходимости маскирования (запрет стрельбы, когда слабое здоровье)
+	chTick    chan int            // Ежесекундная проверка на окончание сражения
+	isEnd     *safe_bool.БезопБул
+}
+
+// NewDivWarOn -- возвращает новый *DivWarOn
+func NewDivWarOn(bot types.ИБот) (*DivWarOn, error) {
+	if bot == nil {
+		return nil, fmt.Errorf("NewDivWarOn(): IBot == nil")
+	}
+	ctxDivWar, fnCancelDivWar := context.WithTimeout(bot.Контекст(), time.Second*305)
+	сам := &DivWarOn{
+		bot:            bot,
+		ctxDivWar:      ctxDivWar,
+		fnCancelDivWar: fnCancelDivWar,
+		login:          bot.Имя(),
+		isMasking:      safe_bool.НовБезопБул(),
+		isEnd:          safe_bool.НовБезопБул(),
+	}
+	аренаКонфиг := arena.АренаКонфиг{
+		Бот_:         bot,
+		АренаИмя_:    "Сражение",
+		СтрКонтроль_: `<title>Сражения</title>`,
+		ФнПуск_:      сам.пуск,
+	}
+	сам.ИАрена = arena.НовАрена(аренаКонфиг)
+	сам.сеть = arena_net.НовАренаСеть(сам, "https://wartank.ru/pve")
+	if сам.checkEnd() {
+		return nil, fmt.Errorf("NewDivWarOn(): нет страницы для сражения")
+	}
+	go сам.makeTick()
+	go сам.run()
+	return сам, nil
+}
+
+// пускает сражение
+func (сам *DivWarOn) пуск() {
+}
+
+// Ежесекудный тик
+func (сам *DivWarOn) makeTick() {
+	defer func() {
+		close(сам.chTick)
+		сам.isEnd.Уст()
+	}()
+	for !сам.isEnd.Получ() {
+		select {
+		case <-сам.bot.Контекст().Done(): // Отмена контекста приложения
+			return
+		case <-сам.ctxDivWar.Done(): // Битва закончилась
+			return
+		default:
+			if сам.isEnd.Получ() {
+				return
+			}
+			сам.chTick <- 1
+			time.Sleep(time.Second * 1)
+		}
+	}
+}
+
+// запускает сражение
+func (сам *DivWarOn) run() {
+	// defer log._rintf("DivWarOn.run(): сражение завершено\n")
+	{ // Подготовка к сражению
+		var err error
+		сам.shot, err = shot.NewShot(сам, сам.login) // Объект выстрела
+		if err != nil {
+			// log._rintf("ERRO DivWarOn.Run(): при создании выстрела танка, err=\n\t%v\n", err)
+			return
+		}
+		сам.health, err = health.NewHealth(сам, сам.shot.IsEnd(), сам.login)
+		if err != nil {
+			// log._rintf("ERRO DivWarOn.Run(): при создании здоровья танка, err=\n\t%v\n", err)
+			сам.shot.IsEnd().Сброс()
+			return
+		}
+		сам.manevr, err = manevr.NewManevr(сам, сам.shot.IsEnd())
+		if err != nil {
+			// log._rintf("ERRO DivWarOn.Run(): при создании маневра танка, err=\n\t%v\n", err)
+			сам.shot.IsEnd().Сброс()
+			return
+		}
+	}
+	for { // Рабочий цикл сражения
+		select {
+		case <-сам.ctxDivWar.Done():
+			return
+		case <-сам.ВремяОстат().КаналСиг():
+			if сам.checkEnd() {
+				return
+			}
+		}
+	}
+}
+
+// Сеть -- возвращает сетевой компонент секции
+func (сам *DivWarOn) Сеть() types.ИАренаСеть {
+	return сам.сеть
+}
+
+// Проверяет окончание сражения
+func (сам *DivWarOn) checkEnd() bool {
+	defer func() {
+		if сам.isEnd.Получ() {
+			сам.fnCancelDivWar()
+			// log._rintf("DivWarOn.checkEnd(): сражение завершено\n")
+		}
+	}()
+
+	сам.сеть.Обновить()
+	lstDivWarOn := сам.СписПолучить()
+	for _, strOut := range lstDivWarOn {
+		if strings.Contains(strOut, `" class="simple-but gray"><span><span>ОБЫЧНЫЕ</span></span></a>`) {
+			сам.isEnd.Сброс()
+			return false
+		}
+	}
+	сам.isEnd.Уст()
+	сам.fnCancelDivWar()
+	return true
+}
+
+// ЕслиКонец -- возвращает признак окончания сражения (интерфейс)
+func (сам *DivWarOn) ЕслиКонец() *safe_bool.БезопБул {
+	return сам.isEnd
+}
+
+func (сам *DivWarOn) Манёвр() {
+	if сам.manevr == nil {
+		return
+	}
+	if сам.manevr.IsReady() {
+		сам.manevr.Manevr()
+	}
+}
+
+// ВыстрелБлок -- признак запрета стрельбы при слабом здоровье
+func (сам *DivWarOn) ВыстрелБлок() *safe_bool.БезопБул {
+	return сам.isMasking
+}
+
+// Ctx -- возвращает контекст отмены сражения
+func (сам *DivWarOn) Ctx() context.Context {
+	return сам.ctxDivWar
+}
+
+// CancelBattle - -вызов функции отмены контекста сражения
+func (сам *DivWarOn) CancelBattle() {
+	сам.fnCancelDivWar()
+}

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

@@ -1,4 +1,4 @@
-package divwar
+package div_war
 
 import (
 	"fmt"
@@ -9,9 +9,9 @@ import (
 	"wartank/pkg/alias"
 	"wartank/pkg/arena"
 	"wartank/pkg/types"
-	"wartank/server/serv_bots/warbot/angar/division/divwar/divwarnet"
-	"wartank/server/serv_bots/warbot/angar/division/divwar/divwaron"
-	"wartank/server/serv_bots/warbot/angar/division/divwar/divwaron/divwarsound"
+	"wartank/server/serv_bots/warbot/angar/division/div_war/div_war_net"
+	"wartank/server/serv_bots/warbot/angar/division/div_war/div_war_on"
+	"wartank/server/serv_bots/warbot/angar/division/div_war/div_war_on/div_war_sound"
 	"wartank/server/serv_bots/warbot/tank_stat/static_param"
 )
 
@@ -24,17 +24,17 @@ type DivWar struct {
 	types.ИАрена
 	bot   types.ИБот
 	alarm types.ИСтатПарам
-	net   *divwarnet.DivWarNet
+	net   *div_war_net.DivWarNet
 	conn  types.ИХттпВоркер
 
 	// Непосредственная битва
-	divon *divwaron.DivWarOn
-	login string // Для несоредственной битвы дивизий
+	дивОн *div_war_on.DivWarOn
+	login string // Для непосредственной битвы дивизий
 	block sync.Mutex
 
 	chDivWar chan int // Сигнал начала битвы дивизий
 
-	sound *divwarsound.DivWarSound // Однопоточное проигрывание звука
+	sound *div_war_sound.DivWarSound // Однопоточное проигрывание звука
 }
 
 // NewDivWar -- возвращает новый *DivWar
@@ -43,28 +43,38 @@ func NewDivWar(bot types.ИБот) (*DivWar, error) {
 		return nil, fmt.Errorf("NewDivWar(): IBot == nil")
 	}
 	сам := &DivWar{
-		ИАрена:   arena.НовАрена(bot, "Битва дивизий", `<span>до начала `),
 		bot:      bot,
 		alarm:    static_param.НовСтатПарам("alarm"),
 		chDivWar: make(chan int, 1),
-		sound:    divwarsound.NewDivWarSound(),
+		sound:    div_war_sound.NewDivWarSound(),
 		conn:     bot.Сеть().ВебВоркер(),
 		login:    "prospero tank",
 	}
+	аренаКонфиг := arena.АренаКонфиг{
+		Бот_:         bot,
+		АренаИмя_:    "Битва дивизий",
+		СтрКонтроль_: `<span>до начала `,
+		ФнПуск_:      сам.пуск,
+	}
+	сам.ИАрена = arena.НовАрена(аренаКонфиг)
 	// сам.shotTimeFull.Set(8000) // 8000 msec
 	var err error
 	{ // Net
-		сам.net, err = divwarnet.NewDivWarNet(bot)
+		сам.net, err = div_war_net.NewDivWarNet(bot)
 		if err != nil {
 			return nil, fmt.Errorf("NewDivWar(): при создании DivWarNet, err=\n\t%w", err)
 		}
 	}
 	go сам.run()
-	go сам.reservTick()
+	go сам.резервТик()
 	return сам, nil
 }
 
-func (сам *DivWar) reservTick() {
+// запускает в работу битву дивизий
+func (сам *DivWar) пуск() {
+}
+
+func (сам *DivWar) резервТик() {
 	for {
 		select {
 		case <-сам.bot.Контекст().Done():
@@ -76,7 +86,7 @@ func (сам *DivWar) reservTick() {
 			if ct1.Сек() != ct0.Сек() {
 				continue
 			}
-			if сам.divon != nil {
+			if сам.дивОн != nil {
 				continue
 			}
 			сам.chDivWar <- 1
@@ -96,7 +106,7 @@ func (сам *DivWar) run() {
 			сам.upDivWar()
 		case <-сам.chDivWar: // Сигнал к началу сражения
 			сам.block.Lock()
-			if сам.divon != nil {
+			if сам.дивОн != nil {
 				continue
 			}
 			сам.alarm.Уст(1)
@@ -182,7 +192,7 @@ func (сам *DivWar) upDivWar() {
 // Ведёт сражение
 func (сам *DivWar) DivWar() {
 	defer func() {
-		сам.divon = nil
+		сам.дивОн = nil
 		сам.block.Unlock()
 		if err := сам.ОбратВремяУст("01"); err != nil {
 			panic(fmt.Errorf("DivWar.DivWar(): при установке CountDown, err=\n\t%w", err))
@@ -190,14 +200,14 @@ func (сам *DivWar) DivWar() {
 		// log.Printf("INFO DivWar.DivWar(): сражение завершено\n")
 	}()
 	var err error
-	сам.divon, err = divwaron.NewDivWarOn(сам.bot) // IDivWarOn (онлайн)
+	сам.дивОн, err = div_war_on.NewDivWarOn(сам.bot) // IDivWarOn (онлайн)
 	if err != nil {
 		// log._rintf("ERRO DivWar.DivWarOn(): при создании IDivWarOn, err=\n\t%v\n", err)
 		time.Sleep(time.Millisecond * 250)
 		return
 	}
 	// Цикл ожидания окончания сражения
-	for !сам.divon.ЕслиКонец().Получ() {
+	for !сам.дивОн.ЕслиКонец().Получ() {
 		time.Sleep(time.Second * 1)
 	}
 

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

@@ -1,8 +1,7 @@
-package divwarnet
+package div_war_net
 
 import (
 	"fmt"
-
 	"wartank/pkg/components/arena_net"
 	"wartank/pkg/types"
 )
@@ -24,7 +23,7 @@ func NewDivWarNet(bot types.ИБот) (*DivWarNet, error) {
 	}
 
 	сам := &DivWarNet{
-		// SectionNet: sectionnet.NewSectionNet(server, bot, ..., "https://wartank.ru/bitva"),
+		// SectionNet: section_net.NewSectionNet(server, bot, ..., "https://wartank.ru/bitva"),
 		bot: bot,
 	}
 	return сам, nil

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

@@ -1,4 +1,4 @@
-package divwaron
+package div_war_on
 
 import (
 	"context"
@@ -9,9 +9,9 @@ import (
 	"wartank/pkg/components/arena_net"
 	"wartank/pkg/components/safe_bool"
 	"wartank/pkg/types"
-	"wartank/server/serv_bots/warbot/angar/division/divwar/divwaron/health"
-	"wartank/server/serv_bots/warbot/angar/division/divwar/divwaron/manevr"
-	"wartank/server/serv_bots/warbot/angar/division/divwar/divwaron/shot"
+	"wartank/server/serv_bots/warbot/angar/division/div_war/div_war_on/health"
+	"wartank/server/serv_bots/warbot/angar/division/div_war/div_war_on/manevr"
+	"wartank/server/serv_bots/warbot/angar/division/div_war/div_war_on/shot"
 )
 
 /*
@@ -31,7 +31,7 @@ type DivWarOn struct {
 	manevr    *manevr.Manevr // Возможность маневрирования
 	login     string
 	isMasking *safe_bool.БезопБул // Признак необходимости маскирования (запрет стрельбы, когда слабое здоровье)
-	chTick    chan int            // Ежесекудная проверка на окончание сражения
+	chTick    chan int            // Ежесекундная проверка на окончание сражения
 	isEnd     *safe_bool.БезопБул
 }
 
@@ -42,7 +42,6 @@ func NewDivWarOn(bot types.ИБот) (*DivWarOn, error) {
 	}
 	ctxDivWar, fnCancelDivWar := context.WithTimeout(bot.Контекст(), time.Second*305)
 	сам := &DivWarOn{
-		ИАрена:         arena.НовАрена(bot, "Сражение", `<title>Сражения</title>`),
 		bot:            bot,
 		ctxDivWar:      ctxDivWar,
 		fnCancelDivWar: fnCancelDivWar,
@@ -50,6 +49,13 @@ func NewDivWarOn(bot types.ИБот) (*DivWarOn, error) {
 		isMasking:      safe_bool.НовБезопБул(),
 		isEnd:          safe_bool.НовБезопБул(),
 	}
+	аренаКонфиг:= arena.АренаКонфиг{
+		Бот_:         bot,
+		АренаИмя_:    "Сражение",
+		СтрКонтроль_: `<title>Сражения</title>`,
+		ФнПуск_:      сам.пуск,
+	}
+	сам.ИАрена = arena.НовАрена(аренаКонфиг)
 	сам.сеть = arena_net.НовАренаСеть(сам, "https://wartank.ru/pve")
 	if сам.checkEnd() {
 		return nil, fmt.Errorf("NewDivWarOn(): нет страницы для сражения")
@@ -59,6 +65,10 @@ func NewDivWarOn(bot types.ИБот) (*DivWarOn, error) {
 	return сам, nil
 }
 
+// пускает сражение
+func (сам *DivWarOn) пуск() {
+}
+
 // Ежесекудный тик
 func (сам *DivWarOn) makeTick() {
 	defer func() {

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

@@ -28,14 +28,13 @@ func НовТопливоБой(angar types.ИАнгар) (*ТопливоБой
 	return сам, nil
 }
 
-func (сам *ТопливоБой) Пуск() error {
+func (сам *ТопливоБой) Пуск() {
 	go сам.пуск()
-	return nil
 }
 
 func (сам *ТопливоБой) пуск() {
 	for {
-		time.Sleep(time.Second * 30) // Минимальный интервал ожттдания прибавки топлива
+		time.Sleep(time.Second * 30) // Минимальный интервал ожидания прибавки топлива
 		// сам.топливоПолуч()
 		топливо := сам.ангар.Топливо().Получ()
 		if топливо < cons.ТопливоМин { // Минимальная ёмкость бака -- 315
@@ -61,7 +60,7 @@ func (сам *ТопливоБой) пуск() {
 // Получает количество топлива
 
 // Идёт в атаку, если топлива больше cons.ТопливоМин
-func (сам *ТопливоБой) начатьБой() (спискСтрБой []string, err error) {
+func (сам *ТопливоБой) начатьБой() (списСтрБой []string, err error) {
 	// Получить ссылку на атаку
 	// _mt.Println("\t ТопливоБой.начатьБой()")
 	списАнгар := сам.ангар.СписПолучить()
@@ -80,11 +79,11 @@ func (сам *ТопливоБой) начатьБой() (спискСтрБой
 	бойСсылка := списАнгар[1]
 	списАнгар = strings.Split(бойСсылка, `"><span><span>В бой!</span></span></a>`)
 	бойСсылка = "https://wartank.ru/" + списАнгар[0]
-	спискСтрБой, err = сам.Get(бойСсылка)
+	списСтрБой, err = сам.Get(бойСсылка)
 	if err != nil {
 		return nil, fmt.Errorf("ТопливоБой.начатьБой(): in make GET-request to battle, err=\n\t%w", err)
 	}
-	return спискСтрБой, nil
+	return списСтрБой, nil
 }
 
 // Выбирает первого более слабого противника и делает первый выстрел

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

@@ -30,18 +30,23 @@ func НовБитваМастеров(бот types.ИБот) *БитваМаст
 	лог := logger.НовЛоггер("БитваМастеров")
 	лог.Инфо("НовБитваМастеров()\n")
 	лог.Проверить(бот != nil, "НовБитваМастеров(): ИБот == nil\n")
-	арена := arena.НовАрена(бот, "Битва мастеров", `/> Битва мастеров <`)
 	сам := &БитваМастеров{
-		ИАрена: арена,
 		бот:    бот,
 		лог:    лог,
 	}
+	аренаКонфиг:=arena.АренаКонфиг{
+		Бот_:         бот,
+		АренаИмя_:    "Битва мастеров",
+		СтрКонтроль_: `/> Битва мастеров <`,
+		ФнПуск_:      сам.пуск,
+	}
+	сам.ИАрена = arena.НовАрена(аренаКонфиг)
 	сам.сеть = arena_net.НовАренаСеть(сам, "https://wartank.ru/pvp")
 	return сам
 }
 
-// Run -- запускает в работу битву мастеров
-func (сам *БитваМастеров) Run() error {
+// запускает в работу битву мастеров
+func (сам *БитваМастеров) пуск() {
 	_ = сам.goBatMas()
 	go func() {
 		for {
@@ -56,7 +61,6 @@ func (сам *БитваМастеров) Run() error {
 			}
 		}
 	}()
-	return nil
 }
 
 // Вычисляет нужно ли идти в битву мастеров

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

@@ -14,18 +14,23 @@ import (
 
 // Миссии -- забирает золотишко
 type Миссии struct {
-	*arena.Арена
+	types.ИАрена
 	бот  types.ИБот
 	сеть types.ИАренаСеть
 }
 
 // НовМиссии -- возвращает новый *Миссии
 func НовМиссии(бот types.ИБот) (*Миссии, error) {
-	section := arena.НовАрена(бот, "Миссии", `<title>Миссии</title>`)
 	сам := &Миссии{
-		Арена: section,
 		бот:   бот,
 	}
+	аренаКонфиг:=arena.АренаКонфиг{
+		Бот_:         бот,
+		АренаИмя_:    "Миссии",
+		СтрКонтроль_: "<title>Миссии</title>",
+		ФнПуск_:      сам.пуск,
+	}
+	сам.ИАрена = arena.НовАрена(аренаКонфиг)
 	сам.сеть = arena_net.НовАренаСеть(сам, "https://wartank.ru/missions/")
 	_ = types.ИМиссии(сам)
 	return сам, nil

server/serv_bots/warbot/warbot.go

@@ -52,8 +52,8 @@ func ЗагрузитьВарБот(сервер types.ИСервер, номе
 		return nil, fmt.Errorf("ЗагрузитьВарБот(): bot '%v' not found in store", номер)
 	}
 	конфиг := &warbot_config.ВарБотКонфиг{}
-	if err = конфиг.Unmarshall(binData); err != nil {
-		return nil, fmt.Errorf("ЗагрузитьВарБот(): in unmarshall WarBotConfig(%v) from store, err=\n\t%w", номер, err)
+	if err = конфиг.Unmarshal(binData); err != nil {
+		return nil, fmt.Errorf("ЗагрузитьВарБот(): in unmarshal WarBotConfig(%v) from store, err=\n\t%w", номер, err)
 	}
 	сам, err := создатьЯдроВарБот(сервер, конфиг)
 	if err != nil {
@@ -169,10 +169,7 @@ func (сам *ВарБот) Пуск() {
 	if сам.еслиРаботает.Получ() {
 		return
 	}
-	if err := сам.ангар.Пуск(); err != nil {
-		log.Printf("WarBot.Run(): bot(%q) in run angar, err=\n\t%v\n", сам.Имя(), err)
-		return
-	}
+	сам.ангар.Пуск()
 	сам.еслиРаботает.Уст()
 }
 
@@ -196,7 +193,7 @@ func (сам *ВарБот) Сеть() types.ИБотСеть {
 	return сам.сеть
 }
 
-// АвтоИграЕсли -- возвращает признак автоматичского запуска бота
+// АвтоИграЕсли -- возвращает признак автоматического запуска бота
 func (сам *ВарБот) АвтоИграЕсли() bool {
 	return сам.еслиАвтозапуск.Получ()
 }

server/serv_bots/warbot/warbot_config/warbot_config.go

@@ -23,8 +23,8 @@ func (сам *ВарБотКонфиг) Marshall() []byte {
 	return binData
 }
 
-// Unmarshall -- десериализует себя из байтового потока
-func (сам *ВарБотКонфиг) Unmarshall(binData []byte) error {
+// Unmarshal -- десериализует себя из байтового потока
+func (сам *ВарБотКонфиг) Unmarshal(binData []byte) error {
 	err := json.Unmarshal(binData, сам)
 	if err != nil {
 		return fmt.Errorf("WarBotConfig.Unmarshall(): err=\n\t%w", err)