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

// package arsenal -- объект оружейной на базе
package arsenal

import (
	"context"
	"fmt"
	"log"
	"strconv"
	"strings"
	"time"
	"wartank/pkg/arena"
	"wartank/pkg/components/arena_net"
	"wartank/pkg/components/kernel/logger"
	"wartank/pkg/components/web_log"
	"wartank/pkg/types"
	"wartank/server/serv_bots/warbot/tank_stat/static_param"
)

const (
	стрКумулятивы = "кумулятивы"
	стрБронебойки = "бронебойки"
	стрФугасы     = "фугасы"
	стрРемки      = "ремки"
)

// Арсенал -- объект оружейной на базе
type Арсенал struct {
	types.ИАрена
	вЛог         types.ИВебЛог
	лог          types.ИЛоггер
	бот          types.ИБот
	база         types.ИБаза
	сеть         types.ИАренаСеть
	фугас        types.ИСтатПарам
	бронебойка   types.ИСтатПарам
	кумулятив    types.ИСтатПарам
	ремка        types.ИСтатПарам
	уровень      types.ИСтатПарам
	продуктИмя   string           // Что сейчас делается
	продуктКол   types.ИСтатПарам // Сколько делается прямо сейчас
	продуктВремя string           // Сколько осталось времени прямо сейчас
	кнт          context.Context  // контекст шахты
	фнОтмена     func()           // Функция отмены шахты
}

// НовАрсенал -- возвращает новый *Arsenal
func НовАрсенал(база types.ИБаза) (types.ИАрсенал, error) {
	лог := logger.НовЛоггер("Арсенал")
	лог.Инфо("НовАрсенал()\n")

	кнт, фнОтмена := context.WithCancel(база.Контекст())
	сам := &Арсенал{
		бот:        база.Бот(),
		база:       база,
		фугас:      static_param.НовСтатПарам(стрФугасы),
		бронебойка: static_param.НовСтатПарам(стрБронебойки),
		кумулятив:  static_param.НовСтатПарам(стрКумулятивы),
		ремка:      static_param.НовСтатПарам(стрРемки),
		уровень:    static_param.НовСтатПарам("уровень"),
		продуктКол: static_param.НовСтатПарам("свинец"),
		кнт:        кнт,
		фнОтмена:   фнОтмена,

		лог: лог,
	}
	аренаКонфиг := arena.АренаКонфиг{
		Бот_:         база.Бот(),
		АренаИмя_:    "Арсенал",
		СтрКонтроль_: `<span class="green2">Ремкомплект</span><br/>`,
		ФнПуск_:      сам.пуск,
	}
	сам.ИАрена = arena.НовАрена(аренаКонфиг)
	сам.вЛог = web_log.НовВебЛог(true)
	сам.сеть = arena_net.НовАренаСеть(сам, "https://wartank.ru/production/Armory")
	go сам.пуск()
	сам.вЛог.Добавить("НовАрсенал(): Арсенал создан")
	return сам, nil
}

// Уровень -- возвращает уровень шахты
func (сам *Арсенал) Уровень() types.ИСтатПарам {
	return сам.уровень
}

// ПродуктКолСейчас -- возвращает количество производимого продукта
func (сам *Арсенал) ПродуктКолСейчас() int {
	return сам.продуктКол.Получ()
}

// ПродуктИмяСейчас -- возвращает имя производимого продукта
func (сам *Арсенал) ПродуктИмяСейчас() string {
	return сам.продуктИмя
}

// ПродуктВремяСейчас -- сколько осталось времени до производства продукта
func (сам *Арсенал) ПродуктВремяСейчас() string {
	return сам.продуктВремя
	// return сам.Секция.ВремяОпрос().Стр()
}

// запускает обработку арсенала
func (сам *Арсенал) пуск() {
	еслиПостроить := true
	фнРабота := func() {
		defer func() {
			for сам.ВремяОстат().ПолучМилСек() > 0 {
				select {
				case <-сам.кнт.Done():
					return
				default:
					time.Sleep(time.Second * 5)
				}
			}
		}()
		сам.вЛог.Добавить("Арсенал.пуск().фнРабота()\n")
		еслиПостроить = сам.проверитьПостроить()
		if еслиПостроить {
			еслиПостроено, ош := сам.построить()
			if ош != nil {
				return
			}
			if еслиПостроено {
				сам.вЛог.Добавить("построено")
				return
			}
		}
		{ // апгрейд
			счёт := 5
			for счёт > 0 {
				if сам.проапгрейдить() {
					break
				}
				счёт--
			}
		}
		_ = сам.уровеньОбновить()
		ош := сам.СтатаОбновить()
		if ош != nil {
			сам.лог.Ошибка("пуск(): при обновлении статы, ош=\n\t%v\n", ош)
			сам.вЛог.Добавить("пуск(): при обновлении статы, ош=\n\t%w", ош)
		}
		сам.забрать()
		сам.сделать()
		сам.лог.Инфо("пуск(): бот=%q, цикл завершён\n", сам.бот.Имя())
	}
	for {
		фнРабота()
	}
}

// Проверяет необходимость постройки
func (сам *Арсенал) проверитьПостроить() bool {
	сам.вЛог.Добавить("Арсенал.проверитьПостроить()\n")
	_, ош := сам.сеть.ВебВоркер().Получ("https://wartank.ru/building-upgrade/Armory")
	if ош != nil {
		сам.лог.Ошибка("проверитьПостроить(): при выполнении запроса, ош=\n\t%v\n", ош)
		сам.вЛог.Добавить("ОШИБКА Арсенал.проверитьПостроить(): при выполнении запроса, err=\n\t%v\n", ош)
		return false
	}
	return true
}

// Обновляет текущий уровень арсенала (может быть не построена)
func (сам *Арсенал) уровеньОбновить() bool {
	сам.вЛог.Добавить("Арсенал.уровеньОбновить()\n")
	списСтр, ош := сам.сеть.ВебВоркер().Получ("http://wartank.ru/buildings")
	if ош != nil {
		сам.лог.Ошибка("уровеньОбновить(): при выполнении запроса, ош=\n\t%v\n", ош)
		сам.вЛог.Добавить("ОШИБКА Арсенал.уровеньОбновить(): in make request, err=\n\t%v\n", ош)
		return false
	}
	// <span class="green2">Оружейная - 0</span><br/>
	var (
		еслиНайти = false
		стр       = ""
	)
	for _, стр = range списСтр {
		if strings.Contains(стр, `<span class="green2">Оружейная -`) {
			еслиНайти = true
			break
		}
	}
	if !еслиНайти {
		сам.вЛог.Добавить("Арсенал.уровеньОбновить(): не надо\n")
		return false
	}
	_стр := strings.TrimPrefix(стр, `<span class="green2">Оружейная - `)
	_стр = strings.TrimSuffix(_стр, `</span><br/>`)
	иУровень, ош := strconv.Atoi(_стр)
	if ош != nil {
		сам.лог.Ошибка("уровеньОбновить(): строка уровня сбойная, стр=%q, ош=\n\t%v\n", стр, ош)
		сам.вЛог.Добавить("ОШИБКА Арсенал.уровеньОбновить(): строка уровня сбойная, стр=%q, ош=\n\t%v\n", стр, ош)
		return false
	}
	сам.уровень.Уст(иУровень)
	сам.лог.Инфо("уровеньОбновить(): уровень=%d\n", иУровень)
	сам.вЛог.Добавить("Арсенал.уровеньОбновить(): уровень=%d\n", иУровень)
	return true
}

// Строит арсенал при нулевом уровне
func (сам *Арсенал) построить() (bool, error) {
	сам.вЛог.Добавить("Арсенал.построить()\n")
	списСтр, ош := сам.сеть.ВебВоркер().Получ("https://wartank.ru/building-upgrade/Armory")
	if ош != nil {
		сам.лог.Ошибка("построить(): при выполнении запроса, ош=\n\t%v\n", ош)
		сам.вЛог.Добавить("Арсенал.построить(): при выполнении запроса, err=\n\t%v\n", ош)
		return false, fmt.Errorf("")
	}
	// <span class="green2">Арсенал - 0</span><br/>
	var (
		еслиНайти = false
		стр       = ""
	)
	for _, стр = range списСтр {
		if strings.Contains(стр, `ILinkListener-upgradeLink-link`) {
			еслиНайти = true
			break
		}
	}
	if !еслиНайти {
		сам.вЛог.Добавить("Арсенал.построить(): не надо\n")
		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", ош)
		return false, fmt.Errorf("")
	}
	еслиНайти = false
	// "<a class=\"simple-but border mb5\" href=\"Armory?14-1.ILinkListener-upgradeLink-link\">"
	for _, стр = range списСтр {
		if strings.Contains(стр, `ILinkListener-upgradeLink-link`) {
			еслиНайти = true
			break
		}
	}
	if !еслиНайти {
		сам.вЛог.Добавить("Арсенал.построить(): не надо\n")
		return true, nil
	}
	сам.лог.Инфо("построить(): ок\n")
	сам.вЛог.Добавить("Арсенал.построить(): ок\n")
	return true, nil
}

// Пытается проапгрейдить арсенал
func (сам *Арсенал) проапгрейдить() bool {
	сам.вЛог.Добавить("Арсенал.проапгрейдить()\n")
	var (
		еслиНайти = false
		списСтр   []string
		стр       = ""
		ош        error
	)
	фнКупить := func() bool {
		defer time.Sleep(time.Millisecond * 1000)
		списСтр, ош = сам.сеть.ВебВоркер().Получ("https://wartank.ru/building-upgrade/Armory")
		if ош != nil {
			сам.вЛог.Добавить("ОШИБКА Арсенал.проапгрейдить().фнКупить(): при GET-команде 'купить постройку арсенала', err=\n\t%v\n", ош)
			return false
		}
		for _, стр = range списСтр {
			// <a class="simple-but border mb5" href="Armory?5-1.ILinkListener-upgradeLink-link">
			if strings.Contains(стр, `ILinkListener-upgradeLink-link`) {
				еслиНайти = true
				break
			}
		}
		if !еслиНайти {
			сам.вЛог.Добавить("Арсенал.проапгрейдить(): не надо\n")
			return true
		}
		// Пробуем улучшить шахту
		_стр := strings.TrimPrefix(стр, "<a class=\"simple-but border mb5\" href=\"")
		_стр = strings.TrimSuffix(_стр, "\">")
		// https://wartank.ru/building-upgrade/Armory?4-1.ILinkListener-upgradeLink-link
		// <a class="simple-but border mb5" href="Armory?50-1.ILinkListener-upgradeLink-link">
		ссылка := "https://wartank.ru/building-upgrade/" + _стр
		списСтр, ош = сам.сеть.ВебВоркер().Получ(ссылка)
		if ош != nil {
			сам.вЛог.Добавить("ОШИБКА Арсенал.проапгрейдить().фнКупить(): при 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", ссылка, стр)
				return false // Покупка не оплачена
			}
		}
		сам.вЛог.Добавить("Арсенал.проапгрейдить().фнКупить(): ок\n")
		return true
	}

	фнПодтверждение := func() bool {
		for _, стр = range списСтр {
			// <a class="simple-but border w50 mXa mb10" w:id="confirmLink" href="../wicket/page?7-1.ILinkListener-confirmLink"><span><span>да, подтверждаю</span></span></a>
			if strings.Contains(стр, `ILinkListener-confirmLink`) {
				еслиНайти = true
				break
			}
		}
		if !еслиНайти {
			сам.вЛог.Добавить("Арсенал.проапгрейдить().фнПодтверждение(): не надо\n")
			return true
		}
		// Пробуем построить шахту
		_стр := strings.TrimPrefix(стр, `<a class="simple-but border w50 mXa mb10" w:id="confirmLink" href="..`)
		_стр = strings.TrimSuffix(_стр, `"><span><span>да, подтверждаю</span></span></a>`)
		// https://wartank.ru/wicket/page?6-1.ILinkListener-confirmLink
		ссылка := "https://wartank.ru" + _стр
		списСтр, ош = сам.сеть.ВебВоркер().Получ(ссылка)
		if ош != nil {
			сам.вЛог.Добавить("ОШИБКА Арсенал.проапгрейдить().фнПодтверждение(): при GET-команде 'подтвердить постройку склада топлива', err=\n\t%v\n", ош)
			return false
		}
		// Проверить, что постройка состоялась
		for _, стр := range списСтр {
			if strings.Contains(стр, "<title>Вы сделали слишком большую паузу</title>") {
				сам.вЛог.Добавить("ОШИБКА Арсенал.проапгрейдить().фнПодтверждение(): подтверждение покупка склада топлива не прошла\n\tlink=%v\n\tстр=\n\t%v\n", ссылка, стр)
				return false // Покупка не оплачена
			}
		}
		сам.вЛог.Добавить("Арсенал.проапгрейдить().фнПодтверждение(): ок\n")
		return true
	}

	фнКомплекс := func() {
		count := 5
		for count > 0 {
			if фнКупить() {
				if фнПодтверждение() {
					break
				}
			}
			count--
		}
	}
	фнКомплекс()
	return true
}

// Проверяет на забрать оружейную
func (сам *Арсенал) забрать() bool {
	var (
		strOut      string
		ind         int
		еслиНайдено bool
		lstBase     = сам.СписПолучить()
	)
	for ind, strOut = range lstBase {
		if strings.Contains(strOut, `Моя амуниция`) {
			еслиНайдено = true
			ind += 17
			strOut = lstBase[ind]
			break
		}
	}
	if !еслиНайдено {
		return false
	}
	if !strings.Contains(strOut, `"><span><span>Забрать</span></span></a>`) {
		return false
	}
	lstLink := strings.Split(strOut, `<a class="simple-but border" href="`)
	strLink := lstLink[1]
	lstLink = strings.Split(strLink, `"><span><span>Забрать</span></span></a>`)
	// https://wartank.ru/buildings?80-1.ILinkListener-buildings-0-building-rootBlock-actionPanel-takeProductionLink
	strLink = "https://wartank.ru/" + lstLink[0]
	var (
		лстАрсенал []string
		ош         error
	)
	time.Sleep(time.Millisecond * 100)
	лстАрсенал, ош = сам.сеть.Get(strLink)
	if ош != nil {
		log.Printf("Арсенал.забрать(): при выполнении Get-запроса? err=\n\t%v\n", ош)
		return false
	}
	if len(лстАрсенал) == 0 {
		log.Printf("Арсенал.забрать(): len lstBase(%v)==0", len(lstBase))
		return false
	}
	for _, strOut = range лстАрсенал {
		if strings.Contains(strOut, `<title>Производство</title>`) {
			return false
		}
	}
	if ош = сам.СтрОбновить(лстАрсенал); ош != nil {
		log.Printf("Арсенал.checkArsenalGet(): при обновлении lstBase, err=\n\t%v\n", ош)
	}
	if ош = сам.СтрОбновить(лстАрсенал); ош != nil {
		log.Printf("Арсенал.checkArsenalGet(): при обновлении lstArsenal, err=\n\t%v\n", ош)
	}
	return true
}

// Фугасы -- возвращает объект числа фугасов
func (сам *Арсенал) Фугасы() types.ИСтатПарам {
	return сам.фугас
}

// Бронебойки -- возвращает объект бронебойных снарядов
func (сам *Арсенал) Бронебойки() types.ИСтатПарам {
	return сам.бронебойка
}

// Кумулятивы -- возвращает объект бронебойных снарядов
func (сам *Арсенал) Кумулятивы() types.ИСтатПарам {
	return сам.кумулятив
}

// Ремки -- возвращает объект ремкомплектов
func (сам *Арсенал) Ремки() types.ИСтатПарам {
	return сам.ремка
}

// Обновляет состояние арсенала по требованию
func (сам *Арсенал) СтатаОбновить() (err error) {
	сам.вЛог.Добавить("Арсенал.СтатаОбновить()\n")
	сам.сеть.Обновить()
	var (
		strOut     string
		lstArsenal = сам.СписПолучить()
	)
	{ // Найти маркер фугасного снаряда
		for _, стрФугас := range lstArsenal {
			if strings.Contains(стрФугас, `<span class="nwr"><img class="rico vm" src="/images/shells/HighExplosive.png" alt="Фугасный снаряд" title="Фугасный снаряд"/> `) {
				strOut = стрФугас
				break
			}
		}
		списФугас := 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("ОШИБКА Арсенал.СтатаОбновить(): фугас(%v) not number, err=\n\t%w", стрФугас, err)
			сам.вЛог.Добавить("%v\n", ош)
			return ош
		}
		сам.Фугасы().Уст(целФугас)
	}
	{ // Найти маркер бронебойного снаряда
		for _, strArmor := range lstArsenal {
			if strings.Contains(strArmor, `alt="Бронебойный снаряд"`) {
				strOut = strArmor
				break
			}
		}
		lstArmor := strings.Split(strOut, `<span class="nwr"><img class="rico vm" src="/images/shells/ArmorPiercing.png" alt="Бронебойный снаряд" title="Бронебойный снаряд"/> `)
		strArmor := lstArmor[1]
		lstArmor = strings.Split(strArmor, ` &nbsp;&nbsp;</span>`)
		strArmor = lstArmor[0]
		iArmor, err := strconv.Atoi(strArmor)
		if err != nil {
			ош := fmt.Errorf("Арсенал.СтатаОбновить(): armor(%v) not number, err=\n\t%w", strArmor, err)
			сам.вЛог.Добавить("%v\n", ош)
			return ош
		}
		сам.Бронебойки().Уст(iArmor)
		сам.вЛог.Добавить("Арсенал.СтатаОбновить(): бронебойки=%v\n", iArmor)
	}
	{ // Найти маркер кумулятивного снаряда
		for _, стрКумул := range lstArsenal {
			if strings.Contains(стрКумул, `<span class="nwr"><img class="rico vm" src="/images/shells/HollowCharge.png" alt="Кумулятивный снаряд" title="Кумулятивный снаряд"/> `) {
				strOut = стрКумул
				break
			}
		}
		списКумул := 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("Арсенал.СтатаОбновить(): кумул(%v) not number, err=\n\t%w", стрКумул, err)
		}
		сам.Кумулятивы().Уст(целКумул)
	}
	{ // Найти маркер ремкомплекта
		for ind, стрРемка := range lstArsenal {
			if strings.Contains(стрРемка, `<span class="nwr"><img class="rico vm" src="/images/shells/repairkit.gif"/> `) {
				strOut = lstArsenal[ind]
				break
			}
		}
		списРемка := 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("Арсенал.СтатаОбновить(): ремка(%v) not number, err=\n\t%w", стрРемка, err)
		}
		сам.Ремки().Уст(целРемка)
	}
	return nil
}

// Выбирает что надо делать, запускает процесс изготовления
func (сам *Арсенал) сделать() bool {
	сам.сеть.Обновить()
	// _mt.Println("\tArsenalNet.сделать()")
	var (
		ремкаКол  = сам.Ремки().Получ()
		фугасКол  = сам.Фугасы().Получ()
		кумульКол = сам.Кумулятивы().Получ()
		ббКол     = сам.Бронебойки().Получ()
		снарядТип string
	)
	if ремкаКол < 70 { // Контроль ремки по времени суток и минимальному количеству ремок
		for !сам.сделатьРемку() {
		}
		сам.продуктИмя = стрРемки
		return true
	}
	{ // Контроль по числу снарядов. В равных долях без приоритетов
		// снарядТип = стрФугасы
		снарядТип = стрБронебойки
		if ббКол > фугасКол {
			снарядТип = стрФугасы
		}

		if фугасКол > кумульКол {
			снарядТип = стрКумулятивы
		}

		switch снарядТип {
		case стрФугасы: // Мало фугасов
			for !сам.сделатьФугасы() {
			}
		case стрКумулятивы: // Мало кумулятивов
			for !сам.сделатьКумули() {
			}
		case стрБронебойки: // Мало бронебойных
			for !сам.сделатьБронебойки() {
			}
		default:
			// log._rintf("ERRO Арсенал.сделать(): неизвестный тип арсенала(%v)", typeArmor)
		}
		сам.продуктИмя = снарядТип
	}
	return true
}

// Создать бронебойные
func (сам *Арсенал) сделатьБронебойки() bool {
	var (
		стрВых      string
		lstArsenal  = сам.СписПолучить()
		еслиНайдено bool
		инд         int
	)
	for инд, стрВых = range lstArsenal {
		if strings.Contains(стрВых, `<span class="green2">Бронебойный снаряд</span><br/>`) {
			еслиНайдено = true
			break
		}
	}
	if !еслиНайдено {
		return false
	}
	стрВых = lstArsenal[инд+10]
	// Получить ссылку на бронебойные
	lstArmor := strings.Split(стрВых, `<a class="simple-but border" href="`)
	if len(lstArmor) <= 1 { // Тут возможно есть пустая строка
		return true // Считаем, что производство уже запущено
	}
	strLink := lstArmor[1]
	lstArmor = strings.Split(strLink, `"><span><span>Начать производство</span></span></a>`)
	strLink = "https://wartank.ru/production/" + lstArmor[0]
	time.Sleep(time.Millisecond * 50)
	if _, err := сам.сеть.Get(strLink); err != nil {
		// log._rintf("ERRO ArsenalNet.makeArmor(): in update lstArsenal,  err=\n\t%v\n", err)
		return false
	}
	сам.АренаСостояние().СостояниеУст(стрБронебойки)
	return true
}

// Создать кумулятивные
func (сам *Арсенал) сделатьКумули() bool {
	var (
		стрВых      string
		lstArsenal  = сам.СписПолучить()
		еслиНайдено bool
		инд         int
	)
	for инд, стрВых = range lstArsenal {
		if strings.Contains(стрВых, `<span class="green2">Кумулятивный снаряд</span><br/>`) {
			еслиНайдено = true
			break
		}
	}
	if !еслиНайдено {
		return false
	}
	стрВых = lstArsenal[инд+10]
	if !strings.Contains(стрВых, `>Начать производство<`) {
		return false
	}
	// Получить ссылку на кумулятив
	списКумул := 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.makeКумуль(): in make product arsenal кумуль , err=\n\t%v\n", err)
		return false
	}
	сам.АренаСостояние().СостояниеУст(стрКумулятивы)
	return true
}

// Создать фугасы
func (сам *Арсенал) сделатьФугасы() bool {
	var (
		lstArsenal  = сам.СписПолучить()
		стрВых      string
		еслиНайдено bool
		инд         int
	)

	for инд, стрВых = range lstArsenal {
		if strings.Contains(стрВых, `<span class="green2">Фугасный снаряд</span><br/>`) {
			еслиНайдено = true
			break
		}
	}
	if !еслиНайдено {
		return false
	}
	стрВых = lstArsenal[инд+10]
	if !strings.Contains(стрВых, `"><span><span>Начать производство</span></span></a>`) {
		return false
	}
	// Получить ссылку на ремку
	списКумул := 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.makeФугас(): in make request arsenal product, err=\n\t%v\n", err)
		return false
	}
	сам.АренаСостояние().СостояниеУст(стрФугасы)
	// log._rintf("INFO Арсенал.makeФугас()\n")
	return true
}

// Создать ремку. Выполняется если подходят условия
func (сам *Арсенал) сделатьРемку() bool {
	// _mt.Println("\tArsenalNet.makeРемка()")
	var (
		стрВых      string
		еслиНайдено bool
		инд         int
	)
	lstArsenal, ош := сам.сеть.ВебВоркер().Получ("https://wartank.ru/production/Armory")
	if ош != nil {
		log.Printf("Арсенал.сделатьРемку(): при получении страницы арсенала, err=\n\t%v\n", ош)
		return false
	}
	// <span class="green2">Ремкомплект</span><br/>
	for инд, стрВых = range lstArsenal {
		if strings.Contains(стрВых, `<span class="green2">Ремкомплект</span><br/>`) {
			еслиНайдено = true
			break
		}
	}
	if !еслиНайдено {
		return false
	}
	стрВых = lstArsenal[инд+10]
	// Если кривая строка, то надо вернуться
	if strings.Contains(стрВых, `</div></div></div></div></div></div></div></div>`) {
		return true
	}
	// Получить ссылку на ремку
	_ссылка := strings.TrimPrefix(стрВых, `<a class="simple-but border" href="`)
	_ссылка = strings.TrimSuffix(_ссылка, `"><span><span>Начать производство</span></span></a>`)
	// https://wartank.ru/production/Armory?37-1.ILinkListener-productions-3-production-startProduceLink
	ссылка := "https://wartank.ru/production/" + _ссылка
	time.Sleep(time.Millisecond * 50)
	if _, err := сам.сеть.ВебВоркер().Получ(ссылка); err != nil {
		log.Printf("Арсенал.сделатьРемку(): при отдаче команды сделать ремку, err=\n\t%v\n", err)
		return false
	}
	сам.АренаСостояние().СостояниеУст(стрРемки)
	return true
}