d03 Исправления под битву и миссии

pkg/types/ibattle_action.go

@@ -21,6 +21,6 @@ type ИСражениеДействие interface {
 	ВыстрелБлок() *isshot.IsShot
 	// Кнт -- возвращает контекст битвы
 	Кнт() context.Context
-	// ОтменитьДействие -- вызывает контекст отмены битвы
-	ОтменитьДействие()
+	// Отменить -- вызывает контекст отмены битвы
+	Отменить()
 }

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

@@ -57,17 +57,9 @@ func (sf *СражениеИсполнитель) Танковать() {
 	if err != nil {
 		return
 	}
-	sf.еслиНачало.Уст(1)
 	sf.sound.Play()
 	time.Sleep(time.Second * 10) // Задержка для звука на странице
-	sf.еслиНачало.Уст(0)
-	// Ожидание завершения
-	go func() {
-		time.Sleep(time.Minute * 6)
-		sf.действие.ОтменитьДействие()
-	}()
 	<-sf.действие.Кнт().Done()
-	sf.SetCountDown(2)
 	// log._rintf("Battle.runBaton(): сражение завершено\n")
 }
 

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

@@ -3,7 +3,6 @@ package battleon
 import (
 	"context"
 	"fmt"
-	"strings"
 	"time"
 
 	"wartank/pkg/components/section"
@@ -32,7 +31,6 @@ type СражениеДействие struct {
 	манёвр      *manevr.Манёвр   // Возможность маневрирования
 	логин       string
 	еслиВыстрел *isshot.IsShot // Признак необходимости маскирования (запрет стрельбы, когда слабое здоровье)
-	chTick      chan int       // Ежесекудная проверка на окончание сражения
 }
 
 // НовСражениеДействие -- возвращает новый *BattleOn
@@ -43,49 +41,32 @@ func НовСражениеДействие(bot types.ИБот) (*Сражени
 	}
 
 	кнтСражение, фнОтменить := context.WithTimeout(bot.Сервер().CtxApp(), time.Second*305)
-	sf := &СражениеДействие{
+	сам := &СражениеДействие{
 		Section:     section,
 		бот:         bot,
 		кнт:         кнтСражение,
 		фнОтменить:  фнОтменить,
 		логин:       bot.Имя(),
 		еслиВыстрел: isshot.NewIsShot(),
-		chTick:      make(chan int, 2),
 	}
-	sf.сеть, err = sectionnet.NewSectionNet(sf, "https://wartank.ru/pve")
+	сам.сеть, err = sectionnet.NewSectionNet(сам, "https://wartank.ru/pve")
 	if err != nil {
 		return nil, fmt.Errorf("NewBattleOn(): in create *SectionNet, err=\n\t%w", err)
 	}
-	go sf.makeTick()
-	go sf.пуск()
-	return sf, nil
-}
-
-// Ежесекудный тик
-func (сам *СражениеДействие) makeTick() {
-	defer func() {
-		close(сам.chTick)
+	go сам.пуск()
+	// Ожидание завершения
+	go func() {
+		time.Sleep(time.Minute * 6)
+		сам.Отменить()
 	}()
-	for {
-		select {
-		case <-сам.бот.Кнт().Done(): // Отмена контекста приложения
-			сам.фнОтменить()
-			return
-		case <-сам.кнт.Done(): // Битва закончилась
-			return
-		default:
-			сам.chTick <- 1
-			time.Sleep(time.Second * 1)
-		}
-
-	}
+	_ = types.ИСражениеДействие(сам)
+	return сам, nil
 }
 
 // запускает сражение
 func (сам *СражениеДействие) пуск() {
 	defer func() {
 		сам.фнОтменить()
-		time.Sleep(time.Second * 20)
 		// log._rintf("BattleOn.run(): сражение завершено\n")
 	}()
 	{ // Подготовка к сражению
@@ -106,18 +87,8 @@ func (сам *СражениеДействие) пуск() {
 			return
 		}
 	}
-	for { // Рабочий цикл сражения
-		select {
-		case <-сам.бот.Кнт().Done(): // Прерывание работы от бота
-			return
-		case <-сам.ВремяОпрос().КаналСиг(): // Вышло время (сигнал от секции)
-			return
-		case <-сам.кнт.Done():
-			return
-		case <-сам.chTick: // Ежесекундный сигнал в сражении
-			сам.проверКонец()
-		}
-	}
+	// Рабочий цикл сражения
+	<-сам.кнт.Done()
 }
 
 // Сеть -- возвращает сетевой компонент секции
@@ -125,29 +96,6 @@ func (sf *СражениеДействие) Сеть() types.ISectionNet {
 	return sf.сеть
 }
 
-// Проверяет окончание сражения
-func (sf *СражениеДействие) проверКонец() {
-	// log._rintf("BattleOn.checkEnd()\n")
-	фнПечатьКонец := func() {
-		sf.фнОтменить()
-		// log._rintf("BattleOn.checkEnd(): сражение завершено\n")
-	}
-
-	if err := sf.сеть.UpdateLst(); err != nil {
-		// log._rintf("WARN BattleOn.checkEnd(): при обновлении lstBattleOn, err=\n\t%v\n", err)
-		фнПечатьКонец()
-		return
-	}
-	lstBattleOn := sf.СписПолучить()
-	for _, strOut := range lstBattleOn { // Сражение ещё идёт
-		if strings.Contains(strOut, `" class="simple-but gray"><span><span>ОБЫЧНЫЕ</span></span></a>`) {
-			return
-		}
-	}
-	// Сражение закончилось
-	фнПечатьКонец()
-}
-
 func (sf *СражениеДействие) МанёврНадоУст() {
 	if sf.манёвр == nil {
 		return
@@ -166,6 +114,6 @@ func (sf *СражениеДействие) Кнт() context.Context {
 }
 
 // ОтменитьДействие -- вызов функции отмены контекста сражения
-func (sf *СражениеДействие) ОтменитьДействие() {
+func (sf *СражениеДействие) Отменить() {
 	sf.фнОтменить()
 }

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

@@ -22,33 +22,34 @@ import (
 // Здоровье -- контроль здоровья танка
 type Здоровье struct {
 	types.ИСражениеДействие
-	время              *healthtime.HealthTime // Изменяемое здоровье танка
-	здоровПолн         *healthtime.HealthTime // Полное здоровье танка
-	еслиНадоЛечить     *isrepair.IsRepair     // Необходимость восстановления
-	времяДоЛеч         *repairtime.RepairTime // Время до восстановления
-	логин              string                 // Для поиска контрольных строк
-	chTick             chan int               // Канал для ровной отправки тиков
-	здоровСтароеДельта int                    // Старая дельта потери здоровья
+	время          *healthtime.HealthTime // Изменяемое здоровье танка
+	здоровПолн     *healthtime.HealthTime // Полное здоровье танка
+	здоровТекущ    int                    // Старое доровье (до опроса)
+	еслиНадоЛечить *isrepair.IsRepair     // Необходимость восстановления
+	времяДоЛеч     *repairtime.RepairTime // Время до восстановления
+	логин          string                 // Для поиска контрольных строк
+	канТик         chan int               // Канал для ровной отправки тиков
+	уронСтарый     int                    // Дельта урона здоровью за прошлый шаг
 }
 
 // НовЗдоровье -- возвращает новый *Здоровье
-func НовЗдоровье(battle types.ИСражениеДействие, login string) (*Здоровье, error) {
+func НовЗдоровье(действие types.ИСражениеДействие, логин string) (*Здоровье, error) {
 	{ // Предусловия
-		if battle == nil {
-			return nil, fmt.Errorf("NewHealth(): battle is nil")
+		if действие == nil {
+			return nil, fmt.Errorf("НовЗдоровье(): действие==nil")
 		}
-		if login == "" {
-			return nil, fmt.Errorf("NewHealth(): login is empty")
+		if логин == "" {
+			return nil, fmt.Errorf("НовЗдоровье(): логин пустой")
 		}
 	}
 	sf := &Здоровье{
-		ИСражениеДействие: battle,
+		ИСражениеДействие: действие,
 		время:             healthtime.NewHealthTime(),
 		здоровПолн:        healthtime.NewHealthTime(),
 		еслиНадоЛечить:    isrepair.NewIsRepair(),
 		времяДоЛеч:        repairtime.NewRepairTime(),
-		логин:             login,
-		chTick:            make(chan int, 2),
+		логин:             логин,
+		канТик:            make(chan int, 2),
 	}
 	go sf.makeTik()
 	go sf.пуск()
@@ -58,9 +59,9 @@ func НовЗдоровье(battle types.ИСражениеДействие, log
 // Отправляе ттики с заданным равным интервалом
 func (сам *Здоровье) makeTik() {
 	defer func() {
-		close(сам.chTick)
-		сам.ОтменитьДействие()
-		// log._rintf("Health.makeTick(): сражение завершёно\n")
+		close(сам.канТик)
+		сам.Отменить()
+		// log._rintf("Здоровье.makeTick(): сражение завершёно\n")
 	}()
 	countLow := 0
 	for {
@@ -81,7 +82,7 @@ func (сам *Здоровье) makeTik() {
 				return
 			}
 		}
-		сам.chTick <- 1
+		сам.канТик <- 1
 		time.Sleep(time.Second * 1)
 		сам.времяДоЛеч.Dec()
 	}
@@ -89,17 +90,16 @@ func (сам *Здоровье) makeTik() {
 
 // Главный цикл обработки здоровья в сражении
 func (сам *Здоровье) пуск() {
-	for range сам.chTick {
+	defer func() {
+		сам.Отменить()
+	}()
+	for range сам.канТик {
 		if err := сам.здоровьеНайти(); err != nil { // Найти свой здоровье
-			log.Printf("Health.run(): при попытке найти здоровье, err=\n\t%v\n", err)
-			сам.ОтменитьДействие()
+			log.Printf("Здоровье.run(): при попытке найти здоровье, err=\n\t%v\n", err)
 			return
 		}
 		сам.времЛечитьНайти()
-		if сам.ВыстрелБлок().Get() {
-			if !сам.еслиНадоЛечить.Get() {
-				continue
-			}
+		if сам.еслиНадоЛечить.Get() {
 			сам.лечить()
 		}
 	}
@@ -115,9 +115,8 @@ func (сам *Здоровье) ЕслиМёртвый() bool {
 	lstBattle := сам.СписПолучить()
 	for _, strOut := range lstBattle {
 		if strings.Contains(strOut, `>Ваш танк подбит.`) {
-			// log._rintf("INFO Health.repair(): танк подбит\n")
-			time.Sleep(time.Second * 10)
-			сам.ОтменитьДействие()
+			// log._rintf("INFO Здоровье.repair(): танк подбит\n")
+			сам.Отменить()
 			return true
 		}
 	}
@@ -125,21 +124,21 @@ func (сам *Здоровье) ЕслиМёртвый() bool {
 }
 
 // Ищет время восстановления ремки
-func (sf *Здоровье) времЛечитьНайти() {
+func (сам *Здоровье) времЛечитьНайти() {
 	defer func() {
-		if sf.времяДоЛеч.ЕслиГотово() {
+		if сам.времяДоЛеч.ЕслиМожно() {
 			return
 		}
-		if sf.времяДоЛеч.ЕслиИзменилось() {
-			log.Printf("Health.findRepair(): до ремки=%v\n", sf.времяДоЛеч.Получ())
+		if сам.времяДоЛеч.ЕслиИзменилось() {
+			log.Printf("Здоровье.findRepair(): до ремки=%v\n", сам.времяДоЛеч.Получ())
 		}
 	}()
-	if sf.времяДоЛеч.ЕслиГотово() {
+	if сам.времяДоЛеч.ЕслиМожно() {
 		return
 	}
 	var (
 		strOut    string
-		lstBattle = sf.СписПолучить()
+		lstBattle = сам.СписПолучить()
 		isFind    bool
 		ind       int
 	)
@@ -155,23 +154,22 @@ func (sf *Здоровье) времЛечитьНайти() {
 		}
 	}
 	if !isFind {
-		time.Sleep(time.Second * 1)
 		return
 	}
 	strOut = lstBattle[ind]
 	// <a href="pve?19-14.ILinkListener-currentControl-repairLink" class="simple-but blue"><span><span>12 секунд</span></span></a>
 	lstTime := strings.Split(strOut, `ILinkListener-currentControl-repairLink" class="simple-but blue"><span><span>`)
 	if len(lstTime) < 2 {
-		// log._rintf("ERRO Health.findRepair(): при попытке получить ссылку на ремонт, strOut=\n%v\n", strOut)
-		time.Sleep(time.Second * 1)
+		// log._rintf("ERRO Здоровье.findRepair(): при попытке получить ссылку на ремонт, strOut=\n%v\n", strOut)
+		сам.Отменить()
 		return
 	}
 	strTime := lstTime[1]
 	lstTime = strings.Split(strTime, ` секунд</span></span></a>`)
 	strTime = lstTime[0]
-	if err := sf.времяДоЛеч.Set(strTime); err != nil {
-		// log._rintf("ERRO Health.findRepair(): при установке времени восстановления ремки, err=\n\t%v\n", err)
-		time.Sleep(time.Second * 1)
+	if err := сам.времяДоЛеч.Set(strTime); err != nil {
+		// log._rintf("ERRO Здоровье.findRepair(): при установке времени восстановления ремки, err=\n\t%v\n", err)
+		return
 	}
 }
 
@@ -202,18 +200,17 @@ func (сам *Здоровье) лечить() {
 	strLink = "https://wartank.ru/" + lstLink[0]
 	lstBattleOn, err := сам.Сеть().Get(strLink)
 	if err != nil {
-		// log._rintf("ERRO Health.repair(): при выполнении GET-команды ремонта, err=\n\t%v\n", err)
-		сам.ОтменитьДействие()
+		// log._rintf("ERRO Здоровье.repair(): при выполнении GET-команды ремонта, err=\n\t%v\n", err)
+		сам.Отменить()
 		return
 	}
 	if err = сам.СтрОбновить(lstBattleOn); err != nil {
-		// log._rintf("ERRO Health.repair(): при обновлении lstBattle, err=\n\t%v\n", err)
-		time.Sleep(time.Second * 1)
+		// log._rintf("ERRO Здоровье.repair(): при обновлении lstBattle, err=\n\t%v\n", err)
 		return
 	}
 	// sound.Repair()
 	сам.уст(сам.здоровПолн.Get())
-	// log._rintf("INFO Health.repair(): здоровье восстановлено\n")
+	// log._rintf("INFO Здоровье.repair(): здоровье восстановлено\n")
 }
 
 // Ищет своё здоровье (~)
@@ -226,8 +223,8 @@ func (сам *Здоровье) здоровьеНайти() error {
 	)
 	if len(lstBattle) == 0 { // Принудительно обновим сражение
 		if err := сам.Сеть().UpdateLst(); err != nil {
-			сам.ОтменитьДействие()
-			return fmt.Errorf("Health.findHealth(): пустой lsBattleOn, err=\n\t%w", err)
+			сам.Отменить()
+			return fmt.Errorf("Здоровье.здоровьеНайти(): пустой lstBattle, err=\n\t%w", err)
 		}
 	}
 	for ind, strOut = range lstBattle {
@@ -237,7 +234,7 @@ func (сам *Здоровье) здоровьеНайти() error {
 		}
 	}
 	if !isFind { // Свой танк не найден
-		сам.ОтменитьДействие()
+		сам.Отменить()
 		return fmt.Errorf("Здоровье.здоровьеНайти(): своё здоровье не найдено")
 	}
 	// Свой танк найден, ищем здоровье
@@ -249,58 +246,53 @@ func (сам *Здоровье) здоровьеНайти() error {
 	strHealth = lstHealth[0]
 	iHealth, err := strconv.Atoi(strHealth)
 	if err != nil {
-		сам.ОтменитьДействие()
-		return fmt.Errorf("Health.findHealth(): здоровье(%v) не число, err=%w", strHealth, err)
+		сам.Отменить()
+		return fmt.Errorf("Здоровье.здоровьеНайти(): здоровье(%v) не число, err=%w", strHealth, err)
 	}
 	сам.уст(iHealth)
 	return nil
 }
 
 // уст -- устанавливает текущее здоровье
-func (sf *Здоровье) уст(val int) {
-	if val < 0 {
-		// log._rintf("WARN Health.setHealth(): кривое значение здоровья танка(%v)\n", val)
-		val = 0
+func (сам *Здоровье) уст(знач int) {
+	if знач <= 0 {
+		// log._rintf("WARN Здоровье.уст(): кривое значение здоровья танка(%v)\n", val)
+		знач = 0
+		сам.Отменить()
 		return
 	}
 
-	if val > sf.здоровПолн.Get() {
-		// log._rintf("WARN Health.setHealth(): кривое текущее здоровье, %v/%v\n", val, sf.full.Get())
-		sf.здоровПолн.Set(val)
-		sf.время.Set(val)
-		sf.здоровСтароеДельта = 0
-		sf.ВыстрелБлок().Reset()
-		sf.еслиНадоЛечить.Reset()
+	if знач > сам.здоровПолн.Get() {
+		// log._rintf("WARN Здоровье.уст(): кривое текущее здоровье, %v/%v\n", val, sf.full.Get())
+		сам.здоровПолн.Set(знач)
+		сам.ВыстрелБлок().Reset()
+		сам.еслиНадоЛечить.Reset()
+		сам.здоровТекущ = знач
 		return
 	}
 
-	delta := sf.время.Get() - val
-	if delta > 0 { // Дельта будет больше нуля, если только
-		if delta != sf.здоровСтароеДельта {
-			// log._rintf("INFO Health.setHealth(): потеря здоровья=%v/%v\n", -delta, val)
-			sf.здоровСтароеДельта = delta
-			sf.время.Set(val)
+	дельта := сам.здоровТекущ - знач
+	if дельта > 0 { // Дельта будет больше нуля, если только было попадание в свой танк
+		if дельта != сам.уронСтарый {
+			// log._rintf("INFO Здоровье.уст(): потеря здоровья=%v/%v\n", -delta, val)
+			сам.уронСтарый = дельта
+			сам.здоровТекущ -= знач
 		}
 	}
 
-	switch {
-	case val == 0:
-		sf.время.Set(0)
-		sf.ОтменитьДействие()
+	if знач <= 500 { // Запретить стрельбу
+		сам.ВыстрелБлок().Set() // Установить запрет стрельбы пока слабое здоровье
+		сам.еслиНадоЛечить.Set()
+		// log._rintf("WARN Здоровье.setHealth(): низкий уровень здоровья(%v)\n", val)
+		сам.МанёврНадоУст()
+		return
+	}
+	// Разрешить стрельбу
+	сам.ВыстрелБлок().Reset()
+	сам.еслиНадоЛечить.Reset()
+	if дельта > сам.здоровПолн.Get()*4/10 { // Проверить на критичность падения здоровья на 40%
+		// log._rintf("WARN Здоровье.setHealth(): большая разовая потеря здоровья(%v)\n", delta)
+		сам.МанёврНадоУст()
 		return
-	case val <= 500: // Запретить стрельбу
-		sf.ВыстрелБлок().Set() // Установить запрет стрельбы пока слабое здоровье
-		sf.еслиНадоЛечить.Set()
-		// log._rintf("WARN Health.setHealth(): низкий уровень здоровья(%v)\n", val)
-		sf.МанёврНадоУст()
-	case val > 500: // Разрешить стрельбы
-		sf.ВыстрелБлок().Reset()
-		sf.еслиНадоЛечить.Reset()
-		if delta > sf.здоровПолн.Get()*4/10 { // Проверить на критичность падения здоровья на 40%
-			// log._rintf("WARN Health.setHealth(): большая разовая потеря здоровья(%v)\n", delta)
-			sf.еслиНадоЛечить.Set()
-			sf.МанёврНадоУст()
-			return
-		}
 	}
 }

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

@@ -63,7 +63,7 @@ func (sf *RepairTime) Dec() {
 }
 
 // ЕслиГотово -- возвращает признак готовности восстановления
-func (sf *RepairTime) ЕслиГотово() bool {
+func (sf *RepairTime) ЕслиМожно() bool {
 	sf.block.RLock()
 	defer sf.block.RUnlock()
 	return sf.val == 0

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

@@ -99,7 +99,7 @@ func (сам *Манёвр) времяМанёврНайти() {
 			return
 		}
 		logrus.WithField("strOut", strOut).Warn("Манёвр.времяМанёврНайти(): ошибка в поиске времени манёвра")
-		сам.ОтменитьДействие()
+		сам.Отменить()
 		return
 	}
 	{ // Найти время манёвра
@@ -110,7 +110,7 @@ func (сам *Манёвр) времяМанёврНайти() {
 				WithField("lstBattleOn[ind]", strOut).
 				WithField("lstBattleOn[+1]", lstBattleOn[ind+1]).
 				Errorf("Manevr.findManevrTime(): нет двух полей во времени ожидания")
-			сам.ОтменитьДействие()
+			сам.Отменить()
 			return
 		}
 		strTime := lstTime[1]
@@ -118,7 +118,7 @@ func (сам *Манёвр) времяМанёврНайти() {
 		strTime = lstTime[0]
 		if err := сам.времяЖдать.Set(strTime); err != nil {
 			logrus.WithError(err).Error("Manevr.findManevrTime(): при обновлении времени ожидания манёвра")
-			сам.ОтменитьДействие()
+			сам.Отменить()
 			return
 		}
 	}
@@ -150,12 +150,12 @@ func (сам *Манёвр) манёвр() {
 		lstBattleOn, err := сам.Сеть().Get(strLink)
 		if err != nil {
 			logrus.WithError(err).Error("Manevr.Manevr(): при выполнении GET-команды маневра")
-			сам.ОтменитьДействие()
+			сам.Отменить()
 			return
 		}
 		if err = сам.СтрОбновить(lstBattleOn); err != nil {
 			logrus.WithError(err).Error("Manevr.Manevr(): при обновлении lstBattle")
-			сам.ОтменитьДействие()
+			сам.Отменить()
 			return
 		}
 		// sound.Manevr()
@@ -165,7 +165,7 @@ func (сам *Манёвр) манёвр() {
 
 // ЕслиГотов -- возвращает готовность манёвра
 func (sf *Манёвр) ЕслиГотов() bool {
-	return sf.времяЖдать.ЕслиГотово()
+	return sf.времяЖдать.ЕслиМожно()
 }
 
 // УстНадо -- устанавливает признак необходимости манёвра

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

@@ -31,37 +31,37 @@ type Выстрел struct {
 	урон                    *damage.Damage     // Урон от выстрела с памятью
 	уронВсего               alias.ADamage      // Суммарный урон
 	логин                   string             // Логин для поиска контрольных строк
-	chTick                  chan int           // Тик для выстрела
+	канТик                  chan int           // Тик для выстрела
 }
 
 // НовВыстрел -- возвращает новый *Shot
-func НовВыстрел(battle types.ИСражениеДействие, login string) (*Выстрел, error) {
+func НовВыстрел(действие types.ИСражениеДействие, логин string) (*Выстрел, error) {
 	{ // Предусловия
-		if battle == nil {
-			return nil, fmt.Errorf("NewShot(): battle is nil")
+		if действие == nil {
+			return nil, fmt.Errorf("НовВыстрел(): действие==nil")
 		}
-		if login == "" {
-			return nil, fmt.Errorf("NewShot(): login is empty")
+		if логин == "" {
+			return nil, fmt.Errorf("НовВыстрел(): логин пустой")
 		}
 	}
 	sf := &Выстрел{
-		ИСражениеДействие: battle,
+		ИСражениеДействие: действие,
 		времяПерезаряд:    shottime.NewShotTime(),
 		урон:              damage.NewDamage(),
-		логин:             login,
-		chTick:            make(chan int, 2),
+		логин:             логин,
+		канТик:            make(chan int, 2),
 	}
 	// Установить время перезарядки
 	sf.времяПерезаряд.Set(6800)
-	go sf.makeTick()
+	go sf.делайТик()
 	go sf.пуск()
 	return sf, nil
 }
 
 // Генерирует тики, когда можно стрелять
-func (сам *Выстрел) makeTick() {
+func (сам *Выстрел) делайТик() {
 	defer func() {
-		close(сам.chTick)
+		close(сам.канТик)
 		// log._rintf("Shot.makeTick(): сражение завершёно\n")
 	}()
 	for {
@@ -69,18 +69,18 @@ func (сам *Выстрел) makeTick() {
 		case <-сам.Кнт().Done():
 			return
 		default:
-			сам.chTick <- 1 // Первый выстрел, потом спать по таймингу
-			recharge := сам.времяПерезаряд.Get()
+			сам.канТик <- 1 // Первый выстрел, потом спать по таймингу
+			перезарядка := сам.времяПерезаряд.Get()
 			// log._rintf("INFO Shot.run() перезарядка=%v msec\n", recharge)
 			// Если идёт перезарядка -- постепенно обнуляем время ожидания
-			time.Sleep(time.Millisecond * time.Duration(recharge))
+			time.Sleep(time.Millisecond * time.Duration(перезарядка))
 		}
 	}
 }
 
 // Цикл выстрела (в отдельном потоке)
 func (сам *Выстрел) пуск() {
-	for range сам.chTick {
+	for range сам.канТик {
 		if сам.ВыстрелБлок().Get() { // Стрелять нельзя
 			continue
 		}
@@ -97,26 +97,25 @@ func (сам *Выстрел) выстрел() {
 	if err := сам.Сеть().UpdateLst(); err != nil { // Проверка на непосредственно битву
 		// <span>закончилась 00:00:07 назад</span>
 		// log._rintf("ERRO Shot.shot(): при обновлении lstBattleOn, err=\n\t%v\n", err)
-		time.Sleep(time.Second * 1)
-		сам.ОтменитьДействие()
+		сам.Отменить()
 		return
 	}
 	var (
-		strOut    string
-		lstBattle = сам.СписПолучить()
-		isFind    bool
-		err       error
+		strOut      string
+		lstBattle   = сам.СписПолучить()
+		еслиНайдено bool
+		err         error
 	)
 	// <a href="pve?6-26.ILinkListener-currentControl-attackRegularShellLink" class="simple-but gray"><span><span>ОБЫЧНЫЕ</span></span></a>
 	for _, strOut = range lstBattle {
 		if strings.Contains(strOut, `-currentControl-attackRegularShellLink`) {
-			isFind = true
+			еслиНайдено = true
 			break
 		}
 	}
-	if !isFind {
+	if !еслиНайдено {
 		// log._rintf("WARN Shot.shot(): не найдены ссылка на выстрел\n")
-		сам.ОтменитьДействие()
+		сам.Отменить()
 		return
 	}
 	lstLink := strings.Split(strOut, `<a href="`)
@@ -126,12 +125,12 @@ func (сам *Выстрел) выстрел() {
 	lstBattle, err = сам.Сеть().Get(strLink)
 	if err != nil {
 		// log._rintf("ERRO Shot.shot(): при исполнении GET-команды выстрела обычным снарядом, err=\n\t%v\n", err)
-		сам.ОтменитьДействие()
+		сам.Отменить()
 		return
 	}
 	if err = сам.СтрОбновить(lstBattle); err != nil {
 		// log._rintf("ERRO Shot.shot(): при обновлении lstBattle, err=\n\t%v\n", err)
-		сам.ОтменитьДействие()
+		сам.Отменить()
 		return
 	}
 	сам.МанёврНадоУст()
@@ -158,7 +157,6 @@ func (сам *Выстрел) найтиУрон() {
 	}
 	if !isFind { // Возможно был рикошет или манёвр
 		// log._rintf("WARN Shot.findDamage(): не найден урон от выстрела, strOut=%q, ind=%v\n", strOut, ind)
-		time.Sleep(time.Second * 1)
 		return
 	}
 	lstDamage := strings.Split(strOut, ` на  <span class="red1">`)
@@ -169,13 +167,13 @@ func (сам *Выстрел) найтиУрон() {
 	iDamage, err := strconv.Atoi(strDamage)
 	if err != nil {
 		// log._rintf("ERRO Shot.findDamage(): damage(%v) не число, err=\n\t%v\n", strDamage, err)
-		сам.ОтменитьДействие()
 		return
 	}
 	if iDamage <= 0 { // Кривой урон от выстрела
 		сам.времяПерезаряд.Dec5()
 		// log._rintf("WARN Shot.findDamage(): ошибка в значении урона(%v)\n", iDamage)
 		iDamage = 0
+		return
 	}
 	сам.уронВсего += alias.ADamage(iDamage)
 	// log._rintf("INFO Shot.Damage(): damageSum=%v\n", sf.damageSum)
@@ -184,14 +182,11 @@ func (сам *Выстрел) найтиУрон() {
 		сам.времяПерезаряд.Inc210()
 	}
 	// log._rintf("INFO Shot.findDamage(): выстрел=+%v, урон=%v", iDamage, sf.damageSum)
-	if iDamage == 0 {
-		return
-	}
-	сам.setDamage(alias.ADamage(iDamage))
+	сам.времяПерезарядОбновить(alias.ADamage(iDamage))
 }
 
-// setDamage -- обновляет время перезарядки в зависимости от произведённого урона
-func (sf *Выстрел) setDamage(val alias.ADamage) {
+// времяПерезарядОбновить -- обновляет время перезарядки в зависимости от произведённого урона
+func (sf *Выстрел) времяПерезарядОбновить(val alias.ADamage) {
 	sf.урон.Set(val)
 	switch sf.урон.Result() {
 	case "none":

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

@@ -56,17 +56,16 @@ func (sf *Миссии) пуск() {
 			sf.ВремяОпрос().Стоп()
 			return
 		case <-sf.ВремяОпрос().КаналСиг():
-			// if err := sf.сеть.UpdateLst(); err != nil {
-			// 	// log._rintf("ERRO Миссии.run(): при обновлении lstMissions, err=\n\t%v\n", err)
-			// 	return
-			// }
-			// sf.проверНаграда()
-		}
-		time.Sleep(time.Minute * 1)
-		sf.проверНаграда()
-		if err := sf.SetCountDown(1); err != nil {
-			panic(fmt.Errorf("Миссии.run(): при установке CountDown, err=\n\t%w", err))
+		// if err := sf.сеть.UpdateLst(); err != nil {
+		// 	// log._rintf("ERRO Миссии.run(): при обновлении lstMissions, err=\n\t%v\n", err)
+		// 	return
+		// }
+		// sf.проверНаграда()
+		default:
+			sf.проверНаграда()
+			time.Sleep(time.Minute * 1)
 		}
+
 	}
 }