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

package base

import (
	"fmt"
	"log"
	"strconv"
	"strings"
	"sync"
	"time"

	"wartank/pkg/alias"
	"wartank/pkg/cons"
	"wartank/pkg/section"
	"wartank/pkg/types"
	"wartank/server/serv_bots/warbot/angar/base/arsenal"
	"wartank/server/serv_bots/warbot/angar/base/bank"
	"wartank/server/serv_bots/warbot/angar/base/basenet"
	"wartank/server/serv_bots/warbot/angar/base/fuel"
	"wartank/server/serv_bots/warbot/angar/base/labor"
	"wartank/server/serv_bots/warbot/angar/base/market"
	"wartank/server/serv_bots/warbot/angar/base/mine"
	"wartank/server/serv_bots/warbot/angar/base/polygon"
)

/*
	Объект базы в игре.
*/

const (
	времОжидПлат    = "01:00" // Время ожидания платного ускорения
	времОжидБесплат = "30:00" // Время ожидания бесплатного ускорения

)

// База -- объект базы
type База struct {
	*section.Секция
	бот          types.ИБот
	сеть         *basenet.BaseNet
	арсенал      *arsenal.Арсенал
	банк         *bank.Банк
	полигон      *polygon.Полигон
	шахта        *mine.Шахта
	ранок        *market.Рынок
	складТоплива *fuel.СкладТоплива
	лаборатория  *labor.Лаборатория
	времОстат    int // Сколько времени спать до опроса базы
	блок         sync.Mutex
}

// НовБаза -- возвращает новую базу бота
func НовБаза(ангар types.ИАнгар) (*База, error) {
	section, ош := section.НовСекция(ангар.Бот(), "База", `<title>База</title>`)
	if ош != nil {
		return nil, fmt.Errorf("НовБаза(): in create ISection, err=\n\t%w", ош)
	}
	log.Printf("НовБаза(): %q\n", section.Бот().Имя())
	сам := &База{
		Секция: section,
		бот:    ангар.Бот(),
	}
	{ // База в сети
		сам.сеть, ош = basenet.NewBaseNet(сам)
		if ош != nil {
			return nil, fmt.Errorf("NewBase(): in create NetBase, err=\n\t%w", ош)
		}
	}
	{ // Arsenal
		сам.арсенал, ош = arsenal.НовАрсенал(сам)
		if ош != nil {
			return nil, fmt.Errorf("NewBase(): in create IArsenal, err=\n\t%w", ош)
		}
	}
	{ // Bank
		сам.банк, ош = bank.НовБанк(сам)
		if ош != nil {
			return nil, fmt.Errorf("NewBase(): in create IBank, err=\n\t%w", ош)
		}
	}
	{ // Mine
		сам.шахта, ош = mine.НовШахта(сам)
		if ош != nil {
			return nil, fmt.Errorf("NewBase(): in create IMine, err=\n\t%w", ош)
		}
	}
	{ // Market
		сам.ранок, ош = market.НовРынок(сам)
		if ош != nil {
			return nil, fmt.Errorf("NewBase(): при создании IMarket, err=\n\t%w", ош)
		}
	}
	{ // Polygon
		сам.полигон, ош = polygon.НовПолигон(сам)
		if ош != nil {
			return nil, fmt.Errorf("NewBase(): in create IPolygon, err=\n\t%w", ош)
		}
	}
	{ // Лаборатория
		сам.лаборатория, ош = labor.НоваяЛаборатория(ангар.Бот())
		if ош != nil {
			return nil, fmt.Errorf("НовБаза(): при создании лаборатории, err=\n\t%w", ош)
		}
	}
	{ // Склад топлива
		сам.складТоплива, ош = fuel.НовСкладТоплива(сам)
		if ош != nil {
			return nil, fmt.Errorf("НовБаза(): при создании склада топлива, err=\n\t%w", ош)
		}
	}
	return сам, nil
}

// Запускает базу в обработку
func (сам *База) Пуск() error {
	log.Printf("Base.Run()\n")
	if err := сам.runComponent(); err != nil {
		return fmt.Errorf("Base.Run(): run, err=\n\t%w", err)
	}
	go сам.пуск()
	return nil
}

// Собственная работа
func (сам *База) пуск() {
	фнЦикл := func() {
		defer time.Sleep(time.Minute * 2)
		if ош := сам.сеть.Обновить(); ош != nil { // Обновить состояние базы
			log.Printf("ERRO Base.Run(): при обновлении базы, err=\n\t%v\n", ош)
		}
		сам.проверитьПолигонУсиление()              // Проверить усиление полигона
		if err := сам.проверитьБанк(); err != nil { // Проверка режимов банка
			log.Printf("ERRO Base.Run(): при проверке банка, err=\n\t%v\n", err)
		}
		сам.проверитьАрсенал() // Проверка арсенала
		сам.проверитьШахту()   // Проверка шахты
		сам.setCountDown()     // Установка счётчика времени

	}
	for {
		select {
		case <-сам.Контекст().Done():
			return
		// case <-сам.ВремяОпрос().КаналСиг():
		// 	фнЦикл()
		default:
			log.Printf("База.пуск()\n")
			фнЦикл()
		}
	}
}

// Запускает компоненты
func (сам *База) runComponent() error {
	log.Printf("Base.runComponent()\n")
	сам.блок.Lock()
	defer сам.блок.Unlock()
	if err := сам.арсенал.Пуск(); err != nil {
		return fmt.Errorf("Base.runComponent(): in run IArsenal, err=\n\t%w", err)
	}
	if err := сам.банк.Пуск(); err != nil {
		return fmt.Errorf("Base.runComponent(): in run IBank, err=\n\t%w", err)
	}
	if err := сам.шахта.Пуск(); err != nil {
		return fmt.Errorf("Base.runComponent(): in run IMine, err=\n\t%w", err)
	}
	if err := сам.ранок.Пуск(); err != nil {
		return fmt.Errorf("Base.runComponent(): in run IMarket, err=\n\t%w", err)
	}
	if err := сам.полигон.Пуск(); err != nil {
		return fmt.Errorf("Base.runComponent(): in run IPolygon, err=\n\t%w", err)
	}
	if err := сам.складТоплива.Пуск(); err != nil {
		return fmt.Errorf("Base.runComponent(): при запуске склада топлива, err=\n\t%w", err)
	}
	сам.лаборатория.Пуск()
	return nil
}

// Выбирает время обновления базы по компонентам
func (сам *База) setCountDown() {
	timeBase := сам.банк.ВремяОстат().String()
	timeCount := timeBase
	timeArsenal := сам.арсенал.ВремяОстат().String()
	timeMine := сам.шахта.ВремяОстат().String()
	if timeArsenal < timeCount {
		timeCount = timeArsenal
	}
	if timeMine < timeCount {
		timeCount = timeMine
	}
	if timeCount <= "05" {
		сам.времОстат = 5
		return
	}
	if timeCount > "00:10:00" {
		сам.времОстат = 600
	}
	ош := сам.Секция.ОбратВремяУст(alias.Время(timeCount))
	if ош != nil {
		log.Printf("ERRO Base.setCountDown(): при установке обратного отсчёта времени, err=\n\t%v\n", ош)
		сам.Отмена()
	}
}

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

// Банк -- возвращает объект банка
func (сам *База) Банк() types.ИБанк {
	сам.блок.Lock()
	defer сам.блок.Unlock()
	return сам.банк
}

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

// Шахта -- возвращает объект шахты
func (сам *База) Шахта() types.ИБазаШахта {
	return сам.шахта
}

// Рынок -- возвращает объект рынка
func (сам *База) Рынок() types.ИРынок {
	return сам.ранок
}

// Проверяет на забрать шахту
func (сам *База) проверитьШахту() {
	if сам.шахта.Руда().Получ() == 0 {
		сам.шахтаСтатаОбновить()
	}
	сам.шахтаАпгрейдФорсаж() // Нужно ли ускорить апгрейд шахты
	if сам.шахта.СценаРежим().Режим() == "upgrade" {
		return
	}
	сам.шахтаСтатаОбновить()
	сам.checkMineTime()
}

// Проверяет время ожидания шахты
func (сам *База) checkMineTime() {
	var (
		lstBase     = сам.СписПолучить()
		strOut      string
		еслиНайдено bool
		ind         int
	)
	for ind, strOut = range lstBase {
		if !strings.Contains(strOut, `<span class="green2">Шахта - `) {
			continue
		}
		ind += 11
		strOut = lstBase[ind]
		еслиНайдено = true
		break
	}
	if !еслиНайдено {
		return
	}
	if !strings.Contains(strOut, `<td><div class="value-block lh1"><span><span>`) {
		return
	}
	lstTime := strings.Split(strOut, `<td><div class="value-block lh1"><span><span>`)
	strTime := lstTime[1]
	lstTime = strings.Split(strTime, `</span></span></div></td>`)
	strTime = lstTime[0]
	if err := сам.шахта.Уст(alias.Время(strTime)); err != nil {
		log.Printf("ERRO Base.checkMineTime(): при установке обратного отсчёта(%v), err=\n\t%v\n", strTime, err)
	}
}

// Проверка статистики шахты
func (сам *База) шахтаСтатаОбновить() {
	var (
		lstMine     = сам.СписПолучить()
		strOut      string
		еслиНайдено bool
		ind         int
	)
	{ // Ищем руду
		for _, strOut = range lstMine {
			if strings.Contains(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/ore.png?2" alt="Руда" title="Руда"/>`) {
				еслиНайдено = true
				break
			}
		}
		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)
			if err != nil {
				log.Printf("ERRO Base.checkMineStat(): руда(%v) не число, err=\n\t%v\n", strRuda, err)
				return
			}
			сам.шахта.Руда().Уст(iRuda)
		}
	}
	{ // Ищем железо
		for _, strOut = range lstMine {
			if strings.Contains(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/iron.png?2" alt="Железо" title="Железо"/> `) {
				еслиНайдено = true
				break
			}
		}
		if еслиНайдено && strings.Contains(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/iron.png?2" alt="Железо" title="Железо"/> `) {
			lstFerrum := strings.Split(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/iron.png?2" alt="Железо" title="Железо"/> `)
			strFerrum := lstFerrum[1]
			lstFerrum = strings.Split(strFerrum, ` &nbsp;&nbsp;</span>`)
			strFerrum = lstFerrum[0]
			iFerrum, err := strconv.Atoi(strFerrum)
			if err != nil {
				log.Printf("ERRO Base.checkMineStat(): железо(%v) не число, err=\n\t%v\n", strFerrum, err)
				return
			}
			сам.шахта.Железо().Уст(iFerrum)
		}
	}
	{ // Ищем сталь
		for _, strOut = range lstMine {
			if strings.Contains(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/steel.png?2" alt="Сталь" title="Сталь"/> `) {
				еслиНайдено = true
				break
			}
		}
		if еслиНайдено && strings.Contains(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/steel.png?2" alt="Сталь" title="Сталь"/> `) {
			lstSteel := strings.Split(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/steel.png?2" alt="Сталь" title="Сталь"/> `)
			strSteel := lstSteel[1]
			lstSteel = strings.Split(strSteel, ` &nbsp;&nbsp;</span>`)
			strSteel = lstSteel[0]
			iSteel, err := strconv.Atoi(strSteel)
			if err != nil {
				log.Printf("ERRO Base.checkMineStat(): сталь(%v) не число, err=\n\t%v\n", strSteel, err)
				return
			}
			сам.шахта.Сталь().Уст(iSteel)
		}
	}
	{ // Ищем свинец
		for _, strOut = range lstMine {
			if strings.Contains(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/plumbum.png?2" alt="Свинец" title="Свинец"/> `) {
				еслиНайдено = true
				break
			}
		}
		if еслиНайдено && strings.Contains(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/plumbum.png?2" alt="Свинец" title="Свинец"/> `) {
			lstPlumbum := strings.Split(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/plumbum.png?2" alt="Свинец" title="Свинец"/> `)
			strPlumbum := lstPlumbum[1]
			lstPlumbum = strings.Split(strPlumbum, ` &nbsp;&nbsp;</span>`)
			strPlumbum = lstPlumbum[0]
			iPlumbum, err := strconv.Atoi(strPlumbum)
			if err != nil {
				log.Printf("ERRO Base.checkMineStat(): свинец(%v) не число, err=\n\t%v\n", strPlumbum, err)
				return
			}
			сам.шахта.Свинец().Уст(iPlumbum)
		}
	}
	{ // Ищем время обработки и режим
		lstBase := сам.СписПолучить()
		for ind, strOut = range lstBase {
			if strings.Contains(strOut, `<span class="green2">Шахта - `) {
				еслиНайдено = true
				ind += 11
				strOut = lstBase[ind]
				break
			}
		}
		if еслиНайдено && strings.Contains(strOut, `<td><div class="value-block lh1"><span><span>`) {
			lstTime := strings.Split(strOut, `<td><div class="value-block lh1"><span><span>`)
			strTime := lstTime[1]
			lstTime = strings.Split(strTime, `</span></span></div></td>`)
			strTime = lstTime[0]
			if err := сам.шахта.Уст(alias.Время(strTime)); err != nil {
				log.Printf("ERRO Base.checkMineStat(): при установке времени ожидания шахты(%v)\n\terr=%v\n", strTime, err)
			}
		}

		ind -= 3
		if ind < 0 {
			log.Printf("Base.checkMineStat(): отрицательный индекс(%v)!\n", ind)
			return
		}
		strOut = lstBase[ind]
		switch {
		case strings.Contains(strOut, `/images/icons/iron.png`): // Железо
			lstNum := strings.Split(strOut, `<td class="vam"><div class="nwr pr5 gray1"><img class="rico vm" src="/images/icons/iron.png?2" alt="iron"/>&nbsp;`)
			strNum := lstNum[1]
			lstNum = strings.Split(strNum, `</div></td>`)
			strNum = lstNum[0]
			работа := alias.СценаРабота("Железо-" + strNum)
			сам.шахта.СценаРежим().РаботаУст(работа)
		case strings.Contains(strOut, `/images/icons/ore.png`): // Руда
			lstNum := strings.Split(strOut, `<td class="vam"><div class="nwr pr5 gray1"><img class="rico vm" src="/images/icons/ore.png?2" alt="ore"/>&nbsp;`)
			strNum := lstNum[1]
			lstNum = strings.Split(strNum, `</div></td>`)
			strNum = lstNum[0]
			работа := alias.СценаРабота("Руда-" + strNum)
			сам.шахта.СценаРежим().РаботаУст(работа)
		case strings.Contains(strOut, `/images/icons/steel.png`): // Руда
			lstNum := strings.Split(strOut, `<td class="vam"><div class="nwr pr5 gray1"><img class="rico vm" src="/images/icons/steel.png?2" alt="steel"/>&nbsp;`)
			strNum := lstNum[1]
			lstNum = strings.Split(strNum, `</div></td>`)
			strNum = lstNum[0]
			работа := alias.СценаРабота("Сталь-" + strNum)
			сам.шахта.СценаРежим().РаботаУст(работа)
		}
	}
}

// Проверяет режимы арсенала
func (сам *База) проверитьАрсенал() {
	// countTime := сам.арсенал.ВремяОпрос().Получ()
	// if countTime > 3 {
	// 	return
	// }
	if err := сам.арсенал.СтатаОбновить(); err != nil {
		// log._rintf("ERRO Base.checkArsenal(): при обновлении арсенала, err=\n\t%v\n", err)
		return
	}
	if работа := сам.арсенал.СценаРежим().Работа(); работа == "" {
		сам.проверитьАрсеналРежим()
	}
	сам.проверитьАрсеналУскорение() // Нужно ли ускорить апгрейд арсенала
	if сам.арсенал.СценаРежим().Режим() == cons.РежимАпгрейд {
		return
	}
	сам.проверитьАрсеналВремя()
	сам.проверитьАрсеналРежим()
}

// Проверяет время готовности арсенала
func (сам *База) проверитьАрсеналВремя() {
	var (
		lstBase     = сам.СписПолучить()
		ind         int
		strOut      string
		еслиНайдено bool
	)
	for ind, strOut = range lstBase {
		if !strings.Contains(strOut, `Производит снаряды, ремкомплекты<br/>`) {
			continue
		}
		ind += 10
		strOut = lstBase[ind]
		еслиНайдено = true
		break
	}
	if !еслиНайдено {
		return
	}
	if !strings.Contains(strOut, ":") {
		return
	}
	lstTime := strings.Split(strOut, `<td><div class="value-block lh1"><span><span>`)
	if len(lstTime) != 2 { // Возможно, производство
		return
	}
	strTime := lstTime[1]
	lstTime = strings.Split(strTime, `</span></span></div></td>`)
	strTime = lstTime[0]
	if err := сам.арсенал.Уст(alias.Время(strTime)); err != nil {
		log.Printf("ERRO Base.checkArsenalTime(): при установке времени ожидания арсенала(%v)\n\terr=%v\n", strTime, err)
	}
}

// Проверяет режим производства арсенала
func (сам *База) проверитьАрсеналРежим() {
	var (
		strOut  string
		lstBase = сам.СписПолучить()
	)
	for _, strOut = range lstBase {
		if strings.Contains(strOut, `HollowCharge.png`) {
			сам.арсенал.СценаРежим().РежимУст("кумулятивы")
			return
		}
		if strings.Contains(strOut, `ArmorPiercing.png`) {
			сам.арсенал.СценаРежим().РежимУст("бронебойки")
			return
		}
		if strings.Contains(strOut, `HighExplosive.png`) {
			сам.арсенал.СценаРежим().РежимУст("фугасы")
			return
		}
		if strings.Contains(strOut, `repairkit.gif`) {
			сам.арсенал.СценаРежим().РежимУст("ремки")
			return
		}
	}
}

// Проверяет на ускорение апгрейда арсенала
func (сам *База) проверитьАрсеналУскорение() {
	var (
		ind         int
		strOut      = ""
		еслиНайдено bool
		lstBase     = сам.СписПолучить()
	)
	{ // Проверка на платное ускорение апгрейда + время
		for ind, strOut = range lstBase {
			if strings.Contains(strOut, `Производит снаряды, ремкомплекты<br/>`) {
				// Убедиться что есть строка платного ускорения
				еслиНайдено = true
				ind += 29
				strOut = lstBase[ind]
				break
			}
		}
		if !еслиНайдено {
			return
		}
		{ // Платное ускорение
			if strings.Contains(strOut, `Ускорить за`) {
				if err := сам.арсенал.ОбратВремяУст(времОжидПлат); err != nil {
					log.Printf("WARN Base.checkArsenalForce(): при установке платного времени ускорения апгрейда арсенала(%v)\n\terr=%v\n", времОжидПлат, err)
				}
				сам.арсенал.СценаРежим().РаботаУст("апгрейд")
				сам.арсенал.СценаРежим().РежимУст(cons.РежимАпгрейд)
				return
			}
		}
	}
	{ // Проверка на бесплатное ускорение апгрейда
		еслиНайдено = false
		for ind, strOut = range lstBase {
			if strings.Contains(strOut, `Производит снаряды, ремкомплекты<br/>`) {
				// Убедиться что есть строка платного ускорения
				еслиНайдено = true
				ind += 26
				strOut = lstBase[ind]
				break
			}
		}
		if !еслиНайдено {
			return
		}
		if !strings.Contains(strOut, `>Ускорение<`) {
			return
		}
		сам.арсенал.СценаРежим().РежимУст(cons.РежимАпгрейд)
		lstLink := strings.Split(strOut, `<td style="width:50%;padding-left:1px;"><a class="simple-but border" href="`)
		strLink := lstLink[1]
		lstLink = strings.Split(strLink, `"><span><span>Ускорение</span></span></a>`)
		strLink = "https://wartank.ru/" + lstLink[0]
		lstBase, err := сам.сеть.Get(strLink)
		if err != nil {
			// log._rintf("ERRO NetBank.checkArsenalForce(): при GET-запросе на бесплатном ускорении апгрейда арсенала, err=\n\t%v\n", err)
			return
		}
		// sound.ArsenalForce()
		if err := сам.СтрОбновить(lstBase); err != nil {
			// log._rintf("ERRO NetBank.checkArsenalForce(): при обновлении lstBase, err=\n\t%v\n", err)
			return
		}
		сам.арсенал.СценаРежим().РаботаУст("апгрейд")
		сам.арсенал.СценаРежим().РежимУст(cons.РежимАпгрейд)
		if err := сам.арсенал.ОбратВремяУст(времОжидБесплат); err != nil {
			log.Printf("WARN Base.checkArsenalForce(): при установке бесплатного времени ускорения апгрейда арсенала(%v)\n\terr=%v\n", времОжидБесплат, err)
		}
	}
	// Все проверки прошли -- это просто работа
	сам.арсенал.СценаРежим().РежимУст(cons.РежимРабота)
}

// Проверяет режим банка
func (сам *База) проверитьБанк() error {
	if сам.банк.СценаРежим().Работа() == "" {
		сам.checkBankMode()
	}
	сам.checkBankTime() // Проверка времени ожидания
	countTime := сам.банк.ВремяОстат().ПолучМилСек()
	if countTime > 5_000 {
		return nil
	}
	сам.checkBankForce() // Нужно ли ускорить апгрейд банка
	if сам.банк.СценаРежим().Режим() == cons.РежимАпгрейд {
		return nil
	}
	сам.checkBankProduct() // Запуск производства в  банке
	return nil
}

// Проверяет режим работы банка
func (сам *База) checkBankMode() {
	var (
		strOut      string
		еслиНайдено bool
		lstBase     = сам.СписПолучить()
	)
	for _, strOut = range lstBase {
		if strings.Contains(strOut, `<td class="vam"><div class="nwr pr5 gray1"><img class="rico vm" src="/images/icons/silver.png?2" alt="silver"/>&nbsp;`) {
			еслиНайдено = true
			break
		}
	}
	if !еслиНайдено {
		return
	}
	lstSilver := strings.Split(strOut, `<td class="vam"><div class="nwr pr5 gray1"><img class="rico vm" src="/images/icons/silver.png?2" alt="silver"/>&nbsp;`)
	strSilver := lstSilver[1]
	lstSilver = strings.Split(strSilver, `</div></td>`)
	работа := alias.СценаРабота("Серебро-" + lstSilver[0])
	сам.банк.СценаРежим().РаботаУст(работа)
	сам.банк.СценаРежим().РежимУст(cons.РежимРабота)

}

// Проверяет на время ожидания банка
func (сам *База) checkBankTime() {
	var (
		strOut      string
		ind         int
		еслиНайдено bool
		lstBase     = сам.СписПолучить()
	)
	for ind, strOut = range lstBase {
		if strings.Contains(strOut, `Производит серебро<br/>`) {
			еслиНайдено = true
			ind += 10
			strOut = lstBase[ind]
			break
		}
	}
	if !еслиНайдено {
		return
	}
	if !strings.Contains(strOut, `<td><div class="value-block lh1"><span><span>`) {
		return
	}
	lstTime := strings.Split(strOut, `<td><div class="value-block lh1"><span><span>`)
	strTime := lstTime[1]
	lstTime = strings.Split(strTime, `</span></span></div></td>`)
	strTime = lstTime[0]
	if err := сам.банк.Уст(alias.Время(strTime)); err != nil {
		log.Printf("ERRO Base.checkBankTime(): при установке времени ожидания банка(%v)\n\terr=%v\n", strTime, err)
	}
}

// Проверяет на произвести в банке
func (сам *База) checkBankProduct() {
	var (
		strOut      string
		ind         int
		еслиНайдено bool
		lstBase     = сам.СписПолучить()
	)
	for ind, strOut = range lstBase {
		if strings.Contains(strOut, `Производит серебро<br/>`) {
			еслиНайдено = true
			ind += 11
			strOut = lstBase[ind]
			break
		}
	}
	if !еслиНайдено {
		return
	}
	if !strings.Contains(strOut, `>Производство</span>`) {
		return
	}
	сам.банк.UpdateLst()
	ош := сам.банк.ОбратВремяУст("01:00")
	if ош != nil {
		log.Printf("ERRO Base.checkBankProduct(): при установке обратного времени ожидания банка, err=\n\t%v\n", ош)
		сам.бот.Сервер().Отменить()
	}
}

// Проверка получения серебра из банка

// Проверяет на ускорение апгрейда банка
func (сам *База) checkBankForce() {
	var (
		ind     int
		strOut  = ""
		isOut   bool
		lstBase = сам.СписПолучить()
	)
	{ // Проверка на платное ускорение апгрейда
		for ind, strOut = range lstBase {
			if strings.Contains(strOut, `Производит серебро<br/>`) {
				// Убедиться что есть строка платного ускорения
				isOut = true
				ind += 29
				strOut = lstBase[ind]
				break
			}
		}
		if isOut && strings.Contains(strOut, `Ускорить за`) {
			if err := сам.банк.ОбратВремяУст(времОжидПлат); err != nil {
				log.Printf("WARN Base.checkBankForce(): при установке времени ожидания платного ускорения апгрейда банка(%v)\n\terr=%v\n", времОжидПлат, err)
			}
			сам.банк.СценаРежим().РаботаУст("апгрейд")
			сам.банк.СценаРежим().РежимУст(cons.РежимАпгрейд)
			return
		}
	}
	{ // Проверка на бесплатное ускорение апгрейда
		isOut = false
		for ind, strOut = range lstBase {
			if strings.Contains(strOut, `Производит серебро<br/>`) {
				// Убедиться что есть строка платного ускорения
				isOut = true
				ind += 26
				strOut = lstBase[ind]
				break
			}
		}
		if isOut && strings.Contains(strOut, `>Ускорение<`) {

			lstLink := strings.Split(strOut, `<td style="width:50%;padding-left:1px;"><a class="simple-but border" href="`)
			strLink := lstLink[1]
			lstLink = strings.Split(strLink, `"><span><span>Ускорение</span></span></a>`)
			strLink = "https://wartank.ru/" + lstLink[0]
			lstBase, err := сам.сеть.Get(strLink)
			if err != nil {
				// log._rintf("ERRO NetBank.checkBankForce(): при GET-запросе на бесплатном ускорении апгрейда банка, err=\n\t%v\n", err)
				return
			}
			if err := сам.СтрОбновить(lstBase); err != nil {
				// log._rintf("ERRO NetBank.checkBankForce(): при обновлении lstBase, err=\n\t%v\n", err)
				return
			}
			сам.банк.СценаРежим().РаботаУст("апгрейд")
			сам.банк.СценаРежим().РежимУст(cons.РежимАпгрейд)
			if err := сам.банк.ОбратВремяУст(времОжидБесплат); err != nil {
				log.Printf("WARN Base.checkBankForce(): при установке времени бесплатного ускорения агрейда банка(%v)\n\terr=%v\n", времОжидБесплат, err)
			}
		}
	}
}

// Проверяет на ускорение апгрейда шахты
func (сам *База) шахтаАпгрейдФорсаж() {
	var (
		ind     int
		strOut  = ""
		isOut   bool
		lstBase = сам.СписПолучить()
	)
	{ // Проверка на платное ускорение апгрейда
		for ind, strOut = range lstBase {
			if strings.Contains(strOut, `Производит ресурсы<br/>`) {
				// Убедиться что есть строка платного ускорения
				isOut = true
				ind += 29
				strOut = lstBase[ind]
				break
			}
		}
		if isOut && strings.Contains(strOut, `Ускорить за`) {
			сам.шахта.СценаРежим().РаботаУст("апгрейд")
			сам.шахта.СценаРежим().РежимУст(cons.РежимАпгрейд)
			if err := сам.шахта.ОбратВремяУст(времОжидПлат); err != nil {
				log.Printf("WARN Base.checkMineForce(): при установке времени платного апгрейда шахты(%v)\n\terr=%v\n", времОжидПлат, err)
			}
			return
		}
	}
	{ // Проверка на время бесплатного ускорение апгрейда
		isOut = false
		for ind, strOut = range lstBase {
			if strings.Contains(strOut, `Производит ресурсы<br/>`) {
				// Убедиться что есть строка платного ускорения
				isOut = true
				ind += 26
				strOut = lstBase[ind]
				break
			}
		}
		if isOut && strings.Contains(strOut, `>Ускорение<`) {
			lstLink := strings.Split(strOut, `<td style="width:50%;padding-left:1px;"><a class="simple-but border" href="`)
			strLink := lstLink[1]
			lstLink = strings.Split(strLink, `"><span><span>Ускорение</span></span></a>`)
			strLink = "https://wartank.ru/" + lstLink[0]
			lstBase, err := сам.сеть.Get(strLink)
			if err != nil {
				// log._rintf("ERRO NetBank.checkMineForce(): при GET-запросе на бесплатном ускорении апгрейда шахты, err=\n\t%v\n", err)
				return
			}
			if err := сам.СтрОбновить(lstBase); err != nil {
				// log._rintf("ERRO NetBank.checkMineForce(): при обновлении lstBase, err=\n\t%v\n", err)
				return
			}
			if err := сам.шахта.ОбратВремяУст(времОжидБесплат); err != nil {
				log.Printf("WARN Base.checkMineForce(): при установке времени апгрейда шахты(%v)\n\terr=%v\n", времОжидБесплат, err)
			}
			// sound.MineForce()
			сам.шахта.СценаРежим().РаботаУст("апгрейд")
			сам.шахта.СценаРежим().РежимУст(cons.РежимАпгрейд)
			return
		}
	}
	// Все проверки прошли -- это просто работа
	сам.шахта.СценаРежим().РежимУст(cons.РежимРабота)
}

// Проверяет на ускорение апгрейда полигона
func (сам *База) проверитьПолигонУсиление() {
	var (
		ind     int
		strOut  = ""
		isOut   bool
		lstBase = сам.СписПолучить()
	)
	countTime := сам.полигон.ВремяОстат().ПолучМилСек()
	if countTime > 3_000 {
		return
	}
	{ // Проверка на платное ускорение апгрейда
		for ind, strOut = range lstBase {
			if strings.Contains(strOut, `Производит усиление танка<br/>`) {
				// Убедиться что есть строка платного ускорения
				isOut = true
				ind += 29
				strOut = lstBase[ind]
				break
			}
		}
		if isOut && strings.Contains(strOut, `Ускорить за`) {
			// strTime := lstBase[ind-21]
			// lstTime := strings.Split(strTime, `<td><div class="value-block lh1"><span><span>`)
			// strTime = lstTime[1]
			// lstTime = strings.Split(strTime, `</span></span></div></td>`)
			// strTime = lstTime[0]
			// if err := сам.polygon.CountDown().Set(strTime); err != nil {
			// 	// log._rintf("WARN Base.checkMineForce(): при установке времени апгрейда полигона(%v)\n\terr=%v\n", strTime, err)
			// }
			сам.полигон.СценаРежим().РаботаУст("апгрейд")
			сам.полигон.СценаРежим().РежимУст(cons.РежимАпгрейд)
			if err := сам.полигон.ОбратВремяУст(времОжидПлат); err != nil {
				log.Printf("WARN Base.checkPolygonForce(): при установке платного времени апгрейда полигона(%v)\n\terr=%v\n", времОжидПлат, err)
			}
			return
		}
	}
	{ // Проверка на бесплатное ускорение апгрейда
		isOut = false
		for ind, strOut = range lstBase {
			if strings.Contains(strOut, `Производит усиление танка<br/>`) {
				// Убедиться что есть строка платного ускорения
				isOut = true
				ind += 26
				strOut = lstBase[ind]
				break
			}
		}
		if isOut && strings.Contains(strOut, `>Ускорение<`) {
			lstLink := strings.Split(strOut, `<td style="width:50%;padding-left:1px;"><a class="simple-but border" href="`)
			strLink := lstLink[1]
			lstLink = strings.Split(strLink, `"><span><span>Ускорение</span></span></a>`)
			strLink = "https://wartank.ru/" + lstLink[0]
			lstBase, err := сам.сеть.Get(strLink)
			if err != nil {
				// log._rintf("ERRO NetBank.checkPolygonForce(): при GET-запросе на бесплатном ускорении апгрейда полигона, err=\n\t%v\n", err)
				return
			}
			if err := сам.СтрОбновить(lstBase); err != nil {
				// log._rintf("ERRO NetBank.checkPolygonForce(): при обновлении lstBase, err=\n\t%v\n", err)
				return
			}
			// sound.MineForce()
			сам.полигон.СценаРежим().РаботаУст("апгрейд")
			сам.полигон.СценаРежим().РежимУст(cons.РежимАпгрейд)
			// Установить время ожидания для обновления
			if err := сам.полигон.ОбратВремяУст(времОжидБесплат); err != nil {
				log.Printf("WARN Base.checkPolygonForce(): при установке времени бесплатного апгрейда полигона(%v)\n\terr=%v\n", времОжидБесплат, err)
			}
			// log._rintf("INFO NetBank.checkPolygonForce(): ускорено строительство полигона\n")
			return
		}
	}
	// Все проверки прошли -- это просто работа
	сам.полигон.СценаРежим().РежимУст(cons.РежимРабота)
}