d03 Исправление ожидания сражения

pkg/types/ibattle_action.go

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

server/serv_bots/warbot/angar/angar.go

@@ -35,7 +35,7 @@ type Ангар struct {
 
 	бот      types.ИБот
 	конвой   *convoy.Convoy
-	сражение *battle.Battle
+	сражение *battle.Сражение
 	битва    *batmas.BatMas
 	база     *base.База
 	миссии   *missions.Миссии
@@ -120,7 +120,7 @@ func НовАнгар(bot types.ИБот) (*Ангар, error) {
 		}
 	}
 	{ // Сражение
-		сам.сражение, err = battle.NewBattle(сам.бот)
+		сам.сражение, err = battle.НовСражение(сам.бот)
 		if err != nil {
 			return nil, fmt.Errorf("НовАнгар(): in create IBattle, err=\n\t%w", err)
 		}
@@ -162,7 +162,7 @@ func (sf *Ангар) Пуск() error {
 		if err := sf.конвой.Run(); err != nil {
 			return fmt.Errorf("Angar.Run(): при пуске конвоя, err=\n\t%w", err)
 		}
-		if err := sf.сражение.Run(); err != nil {
+		if err := sf.сражение.Пуск(); err != nil {
 			return fmt.Errorf("Angar.Run(): при пуске сражения, err=\n\t%w", err)
 		}
 		if err := sf.битва.Run(); err != nil {

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

@@ -13,64 +13,64 @@ import (
 	"wartank/server/serv_bots/warbot/angar/battle/battle_worker"
 )
 
-// Battle -- объект сражения
-type Battle struct {
+// Битва -- объект сражения
+type Сражение struct {
 	*section.Section
-	bot  types.ИБот
-	conn *http.Client
+	бот    types.ИБот
+	клиент *http.Client
 
-	battleRegister *battle_register.BattleRegister // Регистратор на сражение
-	battleWaiter   *battle_wait.BattleWait         // Ождатель начала сражения
-	battleWorker   *battle_worker.BattleWorker     // Исполнитель сражения
+	регистрация *battle_register.BattleRegister    // Регистратор на сражение
+	ожидание    *battle_wait.СражениеОжидание      // Ождатель начала сражения
+	действие    *battle_worker.СражениеИсполнитель // Исполнитель сражения
 
 }
 
-// NewBattle -- возвращает новый *Battle
-func NewBattle(bot types.ИБот) (*Battle, error) {
-	section, err := section.NewSection(bot, "Группа сражения", `<span>до начала `)
+// НовСражение -- возвращает новый *Battle
+func НовСражение(бот types.ИБот) (*Сражение, error) {
+	section, err := section.NewSection(бот, "Группа сражения", `<span>до начала `)
 	if err != nil {
-		return nil, fmt.Errorf("NewBattle(): in create *Section, err=\n\t%w", err)
+		return nil, fmt.Errorf("НовСражение(): in create *Section, err=\n\t%w", err)
 	}
 
-	sf := &Battle{
+	sf := &Сражение{
 		Section: section,
-		bot:     bot,
-		conn:    bot.Сеть().Коннект(),
+		бот:     бот,
+		клиент:  бот.Сеть().Коннект(),
 	}
 	{
-		sf.battleRegister, err = battle_register.NewBattleRegister(bot)
+		sf.регистрация, err = battle_register.NewBattleRegister(бот)
 		if err != nil {
-			return nil, fmt.Errorf("NewBattle(): при создании регистратора на сражения, err=\n\t%w", err)
+			return nil, fmt.Errorf("НовСражение(): при создании регистратора на сражения, err=\n\t%w", err)
 		}
-		sf.battleWaiter, err = battle_wait.NewBattleWait(bot)
+		sf.ожидание, err = battle_wait.НовСражениеОжидание(бот)
 		if err != nil {
-			return nil, fmt.Errorf("NewBattle(): при создании ожидателя сражения, err=\n\t%w", err)
+			return nil, fmt.Errorf("НовСражение(): при создании ожидателя сражения, err=\n\t%w", err)
 		}
-		sf.battleWorker, err = battle_worker.NewBattleWorker(bot)
+		sf.действие, err = battle_worker.НовСражениеИсполнитель(бот)
 		if err != nil {
-			return nil, fmt.Errorf("NewBattle(): при создании исполнителя сражения, err=\n\t%w", err)
+			return nil, fmt.Errorf("НовСражение(): при создании исполнителя сражения, err=\n\t%w", err)
 		}
 	}
 	// sf.shotTimeFull.Set(8000) // 8000 msec
 	return sf, nil
 }
 
-func (sf *Battle) Run() error {
-	go sf.run()
+func (sf *Сражение) Пуск() error {
+	go sf.пуск()
 	return nil
 }
 
 // запускает в работу сражение
-func (sf *Battle) run() {
+func (sf *Сражение) пуск() {
 	// sf.CountDown().SetInt(2)
 	for {
 		select {
-		case <-sf.bot.Кнт().Done():
+		case <-sf.бот.Кнт().Done():
 			return
 		default:
-			sf.battleRegister.Register()
-			sf.battleWaiter.Wait()
-			sf.battleWorker.Work()
+			sf.регистрация.Зарегистрироваться()
+			sf.ожидание.Ожидать()
+			sf.действие.Танковать()
 			for len(sf.ВремяОпрос().КаналСиг()) > 0 {
 				<-sf.ВремяОпрос().КаналСиг()
 			}
@@ -80,6 +80,6 @@ func (sf *Battle) run() {
 }
 
 // ЕслиНачало -- возвращает признак начала сражения (для браузера)
-func (sf *Battle) ЕслиНачало() types.ИСтатПарам {
-	return sf.battleWorker.Alarm()
+func (sf *Сражение) ЕслиНачало() types.ИСтатПарам {
+	return sf.действие.Тревога()
 }

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

@@ -35,8 +35,8 @@ func NewBattleRegister(bot types.ИБот) (*BattleRegister, error) {
 	return sf, nil
 }
 
-// Register -- регистрирует танк на сражение
-func (sf *BattleRegister) Register() {
+// Зарегистрироваться -- регистрирует танк на сражение
+func (sf *BattleRegister) Зарегистрироваться() {
 	if err := sf.net.UpdateLst(); err != nil { // Здесь может уже обратный отсчёт перед сражением
 		return
 	}

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

@@ -12,39 +12,63 @@ import (
 	"wartank/pkg/types"
 )
 
-// BattleWait -- ожидатель начала битвы
-type BattleWait struct {
+// СражениеОжидание -- ожидатель начала битвы
+type СражениеОжидание struct {
 	*section.Section
 	bot types.ИБот
 	net *sectionnet.SectionNet
 }
 
-// NewBattleWait -- возвращает новый ожидатель битвы
-func NewBattleWait(bot types.ИБот) (*BattleWait, error) {
+// НовСражениеОжидание -- возвращает новый ожидатель битвы
+func НовСражениеОжидание(bot types.ИБот) (*СражениеОжидание, error) {
 	section, err := section.NewSection(bot, "Ожидание сражения", `<title>Сражения</title>`)
 	if err != nil {
 		return nil, fmt.Errorf("NewBattleWait(): in create ISection, err=\n\t%w", err)
 	}
 
-	sf := &BattleWait{
+	сам := &СражениеОжидание{
 		Section: section,
 		bot:     bot,
 	}
-	sf.net, err = sectionnet.NewSectionNet(sf, "http://wartank.ru/pve")
+	сам.net, err = sectionnet.NewSectionNet(сам, "http://wartank.ru/pve")
 	if err != nil {
 		return nil, fmt.Errorf("NewBattleWait(): in create *SectionNet, err=\n\t%w", err)
 	}
-	return sf, nil
+	return сам, nil
 }
 
-// Wait -- ожидает начало сражения
-func (sf *BattleWait) Wait() {
-	if err := sf.net.UpdateLst(); err != nil { // Здесь может уже обратный отсчёт перед сражением
-		return
+// Ожидать -- ожидает начало сражения
+func (сам *СражениеОжидание) Ожидать() {
+
+	// Зайти в цикл ожидания сражения
+	for {
+		countTime := сам.ВремяОпрос().Получ()
+		if countTime > 0 {
+			time.Sleep(time.Millisecond * 500)
+			// log.Printf("BattleWait.Wait(): countTime=%v\n", сам.CountDown().String())
+			continue
+		}
+		стрВрем := сам.ждать()
+		if стрВрем == "" {
+			return
+		}
+		if strings.Contains(стрВрем, "00:00:") {
+			time.Sleep(time.Second * 5)
+			continue
+		}
+		time.Sleep(time.Minute * 1)
+		continue
+	}
+}
+
+// Ждёт пока время не обнулится
+func (сам *СражениеОжидание) ждать() string {
+	if err := сам.net.UpdateLst(); err != nil { // Здесь может уже обратный отсчёт перед сражением
+		return ""
 	}
 	var (
 		strOut    string
-		lstBattle = sf.СписПолучить()
+		lstBattle = сам.СписПолучить()
 		isFind    bool
 	)
 	for _, strOut = range lstBattle {
@@ -53,35 +77,23 @@ func (sf *BattleWait) Wait() {
 			break
 		}
 		// if strings.Contains(strOut, `>ОБЫЧНЫЕ<`) { // Это уже битва
-		// 	if len(sf.chBattle) == 0 {
-		// 		sf.chBattle <- 1
+		// 	if len(сам.chBattle) == 0 {
+		// 		сам.chBattle <- 1
 		// 	}
 		// 	return
 		// }
 	}
 	if !isFind { // Сражение уже идёт
-		return
+		return ""
 	}
 	// Найдена строка ожидания начала сражения
 	lstTime := strings.Split(strOut, `<span>до начала `)
 	strTime := lstTime[1]
 	lstTime = strings.Split(strTime, ` (`)
 	strTime = lstTime[0]
-	if err := sf.ParseCountDown(strTime); err != nil {
+	if err := сам.ParseCountDown(strTime); err != nil { // Возможно уже всё
 		// log._rintf("WARN BattleWait.Wait(): при установке времени ожидания сражения(%v)\n\terr=%v\n", strTime, err)
-		return
-	}
-	// Зайти в цикложидания сражения
-	for {
-		countTime := sf.ВремяОпрос().Получ()
-		if countTime > 0 {
-			time.Sleep(time.Millisecond * 500)
-			// log.Printf("BattleWait.Wait(): countTime=%v\n", sf.CountDown().String())
-			continue
-		}
-		for len(sf.ВремяОпрос().КаналСиг()) > 0 {
-			<-sf.ВремяОпрос().КаналСиг()
-		}
-		return
+		return ""
 	}
+	return strTime
 }

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

@@ -13,22 +13,22 @@ import (
 	"wartank/server/serv_bots/warbot/tank/tankstat/static_param"
 )
 
-// BattleWorker -- исполнение битвы
-type BattleWorker struct {
+// СражениеДействие -- исполнение битвы
+type СражениеИсполнитель struct {
 	*section.Section
-	бот types.ИБот
-	net *sectionnet.SectionNet
+	бот  types.ИБот
+	сеть *sectionnet.SectionNet
 
 	еслиНачало types.ИСтатПарам
 
 	// Непосредственное сражение
-	baton *battleon.BattleOn
+	действие *battleon.СражениеДействие
 
 	sound *battlesound.BattleSound // Однопоточное проигрывание звука
 }
 
-// NewBattleWorker -- возвращает новый исполнитель битвы
-func NewBattleWorker(bot types.ИБот) (*BattleWorker, error) {
+// НовСражениеДействие -- возвращает новый исполнитель битвы
+func НовСражениеИсполнитель(bot types.ИБот) (*СражениеИсполнитель, error) {
 	section, err := section.NewSection(bot, "Ход сражения", `<title>Сражения</title>`)
 	if err != nil {
 		return nil, fmt.Errorf("NewBattleWorker(): in create *Section, err=\n\t%w", err)
@@ -37,23 +37,23 @@ func NewBattleWorker(bot types.ИБот) (*BattleWorker, error) {
 	if ош != nil {
 		return nil, fmt.Errorf("NewBattleWorker(): при создании стат еслиНачало, err=\n\t%w", ош)
 	}
-	sf := &BattleWorker{
+	sf := &СражениеИсполнитель{
 		Section:    section,
 		бот:        bot,
 		еслиНачало: еслиНачало,
 		sound:      battlesound.NewBattleSound(),
 	}
-	sf.net, err = sectionnet.NewSectionNet(sf, "http://wartank.ru/pve")
+	sf.сеть, err = sectionnet.NewSectionNet(sf, "http://wartank.ru/pve")
 	if err != nil {
 		return nil, fmt.Errorf("NewBattleWorker(): in create *SectionNet, err=\n\t%w", err)
 	}
 	return sf, nil
 }
 
-// Work -- выполняет битву
-func (sf *BattleWorker) Work() {
+// Танковать -- выполняет битву
+func (sf *СражениеИсполнитель) Танковать() {
 	var err error
-	sf.baton, err = battleon.NewBattleOn(sf.бот) // IBattleOn (онлайн)
+	sf.действие, err = battleon.НовСражениеДействие(sf.бот) // IBattleOn (онлайн)
 	if err != nil {
 		return
 	}
@@ -62,13 +62,13 @@ func (sf *BattleWorker) Work() {
 	time.Sleep(time.Second * 10) // Задержка для звука на странице
 	sf.еслиНачало.Уст(0)
 	// Ожидание завершения
-	<-sf.baton.Кнт().Done()
-	sf.baton = nil
+	<-sf.действие.Кнт().Done()
+	sf.действие = nil
 	sf.SetCountDown(2)
 	// log._rintf("Battle.runBaton(): сражение завершено\n")
 }
 
-// Alarm -- возвращает признак начала сражения (для браузера)
-func (sf *BattleWorker) Alarm() types.ИСтатПарам {
+// Тревога -- возвращает признак начала сражения (для браузера)
+func (sf *СражениеИсполнитель) Тревога() types.ИСтатПарам {
 	return sf.еслиНачало
 }

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

@@ -19,124 +19,123 @@ import (
 	Предоставляет сетевой компонент при непосредственном сражении
 */
 
-// BattleOn -- непосредственно танкует в сражении
-type BattleOn struct {
+// СражениеДействие -- непосредственно танкует в сражении
+type СражениеДействие struct {
 	*section.Section
-	net            *sectionnet.SectionNet
-	bot            types.ИБот
-	ctxBattle      context.Context // Контекст сражения
-	fnCancelBattle func()          // Функция отмены сражения
-
-	shot   *shot.Shot     // Объект выстрела
-	health *health.Health // Текущее здоровье танка
-	manevr *manevr.Manevr // Возможность маневрирования
-	login  string
-	isShot *isshot.IsShot // Признак необходимости маскирования (запрет стрельбы, когда слабое здоровье)
-	chTick chan int       // Ежесекудная проверка на окончание сражения
+	сеть     *sectionnet.SectionNet
+	бот      types.ИБот
+	кнт      context.Context // Контекст сражения
+	фнОтмена func()          // Функция отмены сражения
+
+	выстрел     *shot.Выстрел    // Объект выстрела
+	здоровье    *health.Здоровье // Текущее здоровье танка
+	манёвр      *manevr.Манёвр   // Возможность маневрирования
+	логин       string
+	еслиВыстрел *isshot.IsShot // Признак необходимости маскирования (запрет стрельбы, когда слабое здоровье)
+	chTick      chan int       // Ежесекудная проверка на окончание сражения
 }
 
-// NewBattleOn -- возвращает новый *BattleOn
-func NewBattleOn(bot types.ИБот) (*BattleOn, error) {
+// НовСражениеДействие -- возвращает новый *BattleOn
+func НовСражениеДействие(bot types.ИБот) (*СражениеДействие, error) {
 	section, err := section.NewSection(bot, "Исполнитель сражения", `<title>Сражения</title>`)
 	if err != nil {
-		return nil, fmt.Errorf("NewBattleOn(): in create ISection, err=\n\t%w", err)
+		return nil, fmt.Errorf("НовСражениеДействие(): in create ISection, err=\n\t%w", err)
 	}
 
 	ctxBattle, fnCancelBattle := context.WithTimeout(bot.Сервер().CtxApp(), time.Second*305)
-	sf := &BattleOn{
-		Section:        section,
-		bot:            bot,
-		ctxBattle:      ctxBattle,
-		fnCancelBattle: fnCancelBattle,
-		login:          bot.Имя(),
-		isShot:         isshot.NewIsShot(),
-		chTick:         make(chan int, 2),
+	sf := &СражениеДействие{
+		Section:     section,
+		бот:         bot,
+		кнт:         ctxBattle,
+		фнОтмена:    fnCancelBattle,
+		логин:       bot.Имя(),
+		еслиВыстрел: isshot.NewIsShot(),
+		chTick:      make(chan int, 2),
 	}
-	sf.net, err = sectionnet.NewSectionNet(sf, "http://wartank.ru/pve")
+	sf.сеть, err = sectionnet.NewSectionNet(sf, "http://wartank.ru/pve")
 	if err != nil {
 		return nil, fmt.Errorf("NewBattleOn(): in create *SectionNet, err=\n\t%w", err)
 	}
 	go sf.makeTick()
-	go sf.run()
+	go sf.пуск()
 	return sf, nil
 }
 
 // Ежесекудный тик
-func (sf *BattleOn) makeTick() {
+func (сам *СражениеДействие) makeTick() {
 	defer func() {
-		close(sf.chTick)
+		close(сам.chTick)
 	}()
 	for {
 		select {
-		case <-sf.bot.Кнт().Done(): // Отмена контекста приложения
-			sf.fnCancelBattle()
+		case <-сам.бот.Кнт().Done(): // Отмена контекста приложения
+			сам.фнОтмена()
 			return
-		case <-sf.ctxBattle.Done(): // Битва закончилась
+		case <-сам.кнт.Done(): // Битва закончилась
 			return
 		default:
-			sf.chTick <- 1
+			сам.chTick <- 1
 			time.Sleep(time.Second * 1)
 		}
+
 	}
 }
 
 // запускает сражение
-func (sf *BattleOn) run() {
+func (сам *СражениеДействие) пуск() {
 	defer func() {
-		sf.fnCancelBattle()
+		сам.фнОтмена()
+		time.Sleep(time.Second * 20)
 		// log._rintf("BattleOn.run(): сражение завершено\n")
 	}()
 	{ // Подготовка к сражению
 		var err error
-		sf.shot, err = shot.NewShot(sf, sf.login) // Объект выстрела
+		сам.выстрел, err = shot.НовВыстрел(сам, сам.логин) // Объект выстрела
 		if err != nil {
 			// log._rintf("ERRO BattleOn.Run(): при создании выстрела танка, err=\n\t%v\n", err)
-			time.Sleep(time.Second * 1)
 			return
 		}
-		sf.health, err = health.NewHealth(sf, sf.login)
+		сам.здоровье, err = health.НовЗдоровье(сам, сам.логин)
 		if err != nil {
 			// log._rintf("ERRO BattleOn.Run(): при создании здоровья танка, err=\n\t%v\n", err)
-			time.Sleep(time.Second * 1)
 			return
 		}
-		sf.manevr, err = manevr.NewManevr(sf)
+		сам.манёвр, err = manevr.NewManevr(сам)
 		if err != nil {
 			// log._rintf("ERRO BattleOn.Run(): при создании маневра танка, err=\n\t%v\n", err)
-			time.Sleep(time.Second * 1)
 			return
 		}
 	}
 	for { // Рабочий цикл сражения
 		select {
-		case <-sf.bot.Кнт().Done(): // Прерывание работы от бота
+		case <-сам.бот.Кнт().Done(): // Прерывание работы от бота
 			return
-		case <-sf.ВремяОпрос().КаналСиг(): // Вышло время (сигнал от секции)
+		case <-сам.ВремяОпрос().КаналСиг(): // Вышло время (сигнал от секции)
 			return
-		case <-sf.ctxBattle.Done():
+		case <-сам.кнт.Done():
 			return
-		case <-sf.chTick: // Ежесекундный сигнал в сражении
-			sf.checkEnd()
+		case <-сам.chTick: // Ежесекундный сигнал в сражении
+			сам.проверКонец()
 		}
 	}
 }
 
 // Сеть -- возвращает сетевой компонент секции
-func (sf *BattleOn) Сеть() types.ISectionNet {
-	return sf.net
+func (sf *СражениеДействие) Сеть() types.ISectionNet {
+	return sf.сеть
 }
 
 // Проверяет окончание сражения
-func (sf *BattleOn) checkEnd() {
+func (sf *СражениеДействие) проверКонец() {
 	// log._rintf("BattleOn.checkEnd()\n")
-	fnPrintEnd := func() {
-		sf.fnCancelBattle()
+	фнПечатьКонец := func() {
+		sf.фнОтмена()
 		// log._rintf("BattleOn.checkEnd(): сражение завершено\n")
 	}
 
-	if err := sf.net.UpdateLst(); err != nil {
+	if err := sf.сеть.UpdateLst(); err != nil {
 		// log._rintf("WARN BattleOn.checkEnd(): при обновлении lstBattleOn, err=\n\t%v\n", err)
-		fnPrintEnd()
+		фнПечатьКонец()
 		return
 	}
 	lstBattleOn := sf.СписПолучить()
@@ -146,27 +145,27 @@ func (sf *BattleOn) checkEnd() {
 		}
 	}
 	// Сражение закончилось
-	fnPrintEnd()
+	фнПечатьКонец()
 }
 
-func (sf *BattleOn) МанёврНадоУст() {
-	if sf.manevr == nil {
+func (sf *СражениеДействие) МанёврНадоУст() {
+	if sf.манёвр == nil {
 		return
 	}
-	sf.manevr.SetNeed()
+	sf.манёвр.УстНадо()
 }
 
 // ВыстрелБлок -- признак запрета стрельбы при слабом здоровье
-func (sf *BattleOn) ВыстрелБлок() *isshot.IsShot {
-	return sf.isShot
+func (sf *СражениеДействие) ВыстрелБлок() *isshot.IsShot {
+	return sf.еслиВыстрел
 }
 
 // Кнт -- возвращает контекст отмены сражения
-func (sf *BattleOn) Кнт() context.Context {
-	return sf.ctxBattle
+func (sf *СражениеДействие) Кнт() context.Context {
+	return sf.кнт
 }
 
-// Отменить -- вызов функции отмены контекста сражения
-func (sf *BattleOn) Отменить() {
-	sf.fnCancelBattle()
+// ОтменитьДействие -- вызов функции отмены контекста сражения
+func (sf *СражениеДействие) ОтменитьДействие() {
+	sf.фнОтмена()
 }

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

@@ -19,20 +19,20 @@ import (
 	Контролирует состояние здоровья танка
 */
 
-// Health -- контроль здоровья танка
-type Health struct {
-	types.ИСражеиеДействие
-	temp       *healthtime.HealthTime // Изменяемое здоровье танка
-	full       *healthtime.HealthTime // Полное здоровье танка
-	isRepair   *isrepair.IsRepair     // Необходимость восстановления
-	repairTime *repairtime.RepairTime // Время до восстановления
-	login      string                 // Для поиска контрольных строк
-	chTick     chan int               // Канал для ровной отправки тиков
-	deltaOld   int                    // Старая дельта потери здоровья
+// Здоровье -- контроль здоровья танка
+type Здоровье struct {
+	types.ИСражениеДействие
+	время              *healthtime.HealthTime // Изменяемое здоровье танка
+	здоровПолн         *healthtime.HealthTime // Полное здоровье танка
+	еслиНадоЛечить     *isrepair.IsRepair     // Необходимость восстановления
+	времяДоЛеч         *repairtime.RepairTime // Время до восстановления
+	логин              string                 // Для поиска контрольных строк
+	chTick             chan int               // Канал для ровной отправки тиков
+	здоровСтароеДельта int                    // Старая дельта потери здоровья
 }
 
-// NewHealth -- возвращает новый *Health
-func NewHealth(battle types.ИСражеиеДействие, login string) (*Health, error) {
+// НовЗдоровье -- возвращает новый *Здоровье
+func НовЗдоровье(battle types.ИСражениеДействие, login string) (*Здоровье, error) {
 	{ // Предусловия
 		if battle == nil {
 			return nil, fmt.Errorf("NewHealth(): battle is nil")
@@ -41,37 +41,37 @@ func NewHealth(battle types.ИСражеиеДействие, login string) (*He
 			return nil, fmt.Errorf("NewHealth(): login is empty")
 		}
 	}
-	sf := &Health{
-		ИСражеиеДействие: battle,
-		temp:             healthtime.NewHealthTime(),
-		full:             healthtime.NewHealthTime(),
-		isRepair:         isrepair.NewIsRepair(),
-		repairTime:       repairtime.NewRepairTime(),
-		login:            login,
-		chTick:           make(chan int, 2),
+	sf := &Здоровье{
+		ИСражениеДействие: battle,
+		время:             healthtime.NewHealthTime(),
+		здоровПолн:        healthtime.NewHealthTime(),
+		еслиНадоЛечить:    isrepair.NewIsRepair(),
+		времяДоЛеч:        repairtime.NewRepairTime(),
+		логин:             login,
+		chTick:            make(chan int, 2),
 	}
 	go sf.makeTik()
-	go sf.run()
+	go sf.пуск()
 	return sf, nil
 }
 
 // Отправляе ттики с заданным равным интервалом
-func (sf *Health) makeTik() {
+func (сам *Здоровье) makeTik() {
 	defer func() {
-		close(sf.chTick)
-		sf.Отменить()
+		close(сам.chTick)
+		сам.ОтменитьДействие()
 		// log._rintf("Health.makeTick(): сражение завершёно\n")
 	}()
 	countLow := 0
 	for {
 		select {
-		case <-sf.Кнт().Done():
+		case <-сам.Кнт().Done():
 			return
 		default:
-			if sf.IsDeath() {
+			if сам.ЕслиМёртвый() {
 				return
 			}
-			switch sf.repairTime.Get() <= 0 {
+			switch сам.времяДоЛеч.Получ() <= 0 {
 			case true:
 				countLow++
 			default:
@@ -81,40 +81,43 @@ func (sf *Health) makeTik() {
 				return
 			}
 		}
-		sf.chTick <- 1
+		сам.chTick <- 1
 		time.Sleep(time.Second * 1)
-		sf.repairTime.Dec()
+		сам.времяДоЛеч.Dec()
 	}
 }
 
 // Главный цикл обработки здоровья в сражении
-func (sf *Health) run() {
-	for range sf.chTick {
-		if err := sf.findHealth(); err != nil { // Найти свой здоровье
+func (сам *Здоровье) пуск() {
+	for range сам.chTick {
+		if err := сам.здоровьеНайти(); err != nil { // Найти свой здоровье
 			log.Printf("Health.run(): при попытке найти здоровье, err=\n\t%v\n", err)
+			сам.ОтменитьДействие()
+			return
 		}
-		sf.findRepairTime()
-		if sf.ВыстрелБлок().Get() {
-			if !sf.isRepair.Get() {
+		сам.времЛечитьНайти()
+		if сам.ВыстрелБлок().Get() {
+			if !сам.еслиНадоЛечить.Get() {
 				continue
 			}
-			sf.repair()
+			сам.лечить()
 		}
 	}
 }
 
-// Full -- возвращает объект полного здоровья танка
-func (sf *Health) Full() int {
-	return sf.full.Get()
+// Полное -- возвращает объект полного здоровья танка
+func (сам *Здоровье) Полное() int {
+	return сам.здоровПолн.Get()
 }
 
-// IsDeath -- возвращает признак мертвичины танка
-func (sf *Health) IsDeath() bool {
-	lstBattle := sf.СписПолучить()
+// ЕслиМёртвый -- возвращает признак мертвичины танка
+func (сам *Здоровье) ЕслиМёртвый() bool {
+	lstBattle := сам.СписПолучить()
 	for _, strOut := range lstBattle {
 		if strings.Contains(strOut, `>Ваш танк подбит.`) {
 			// log._rintf("INFO Health.repair(): танк подбит\n")
-			sf.temp.Set(0)
+			time.Sleep(time.Second * 10)
+			сам.ОтменитьДействие()
 			return true
 		}
 	}
@@ -122,17 +125,16 @@ func (sf *Health) IsDeath() bool {
 }
 
 // Ищет время восстановления ремки
-func (sf *Health) findRepairTime() {
+func (sf *Здоровье) времЛечитьНайти() {
 	defer func() {
-		if sf.repairTime.IsReady() {
+		if sf.времяДоЛеч.ЕслиГотово() {
 			return
 		}
-		if sf.repairTime.IsChange() {
-			log.Printf("Health.findRepair(): до ремки=%v\n", sf.repairTime.Get())
+		if sf.времяДоЛеч.ЕслиИзменилось() {
+			log.Printf("Health.findRepair(): до ремки=%v\n", sf.времяДоЛеч.Получ())
 		}
 	}()
-	if sf.repairTime.IsReady() {
-		time.Sleep(time.Second * 1)
+	if sf.времяДоЛеч.ЕслиГотово() {
 		return
 	}
 	var (
@@ -167,17 +169,17 @@ func (sf *Health) findRepairTime() {
 	strTime := lstTime[1]
 	lstTime = strings.Split(strTime, ` секунд</span></span></a>`)
 	strTime = lstTime[0]
-	if err := sf.repairTime.Set(strTime); err != nil {
+	if err := sf.времяДоЛеч.Set(strTime); err != nil {
 		// log._rintf("ERRO Health.findRepair(): при установке времени восстановления ремки, err=\n\t%v\n", err)
 		time.Sleep(time.Second * 1)
 	}
 }
 
 // Восстановливает здоровье (~)
-func (sf *Health) repair() {
+func (сам *Здоровье) лечить() {
 	var (
 		strOut       string
-		lstBattleOn  = sf.СписПолучить()
+		lstBattleOn  = сам.СписПолучить()
 		isFindRepair bool
 		ind          int
 	)
@@ -190,7 +192,6 @@ func (sf *Health) repair() {
 		}
 	}
 	if !isFindRepair {
-		time.Sleep(time.Second * 1)
 		return
 	}
 	strOut = lstBattleOn[ind]
@@ -199,45 +200,45 @@ func (sf *Health) repair() {
 	strLink := lstLink[1]
 	lstLink = strings.Split(strLink, `" class="simple-but blue"><span><span>Ремкомплект</span></span></a>`)
 	strLink = "http://wartank.ru/" + lstLink[0]
-	lstBattleOn, err := sf.Сеть().Get(strLink)
+	lstBattleOn, err := сам.Сеть().Get(strLink)
 	if err != nil {
 		// log._rintf("ERRO Health.repair(): при выполнении GET-команды ремонта, err=\n\t%v\n", err)
-		time.Sleep(time.Second * 1)
+		сам.ОтменитьДействие()
 		return
 	}
-	if err = sf.СтрОбновить(lstBattleOn); err != nil {
+	if err = сам.СтрОбновить(lstBattleOn); err != nil {
 		// log._rintf("ERRO Health.repair(): при обновлении lstBattle, err=\n\t%v\n", err)
 		time.Sleep(time.Second * 1)
 		return
 	}
 	// sound.Repair()
-	sf.setHealth(sf.full.Get())
+	сам.уст(сам.здоровПолн.Get())
 	// log._rintf("INFO Health.repair(): здоровье восстановлено\n")
 }
 
 // Ищет своё здоровье (~)
-func (sf *Health) findHealth() error {
+func (сам *Здоровье) здоровьеНайти() error {
 	var (
 		ind       int
 		strOut    string
 		isFind    bool
-		lstBattle = sf.СписПолучить()
+		lstBattle = сам.СписПолучить()
 	)
 	if len(lstBattle) == 0 { // Принудительно обновим сражение
-		if err := sf.Сеть().UpdateLst(); err != nil {
-			time.Sleep(time.Second * 1)
+		if err := сам.Сеть().UpdateLst(); err != nil {
+			сам.ОтменитьДействие()
 			return fmt.Errorf("Health.findHealth(): пустой lsBattleOn, err=\n\t%w", err)
 		}
 	}
 	for ind, strOut = range lstBattle {
-		if strings.Contains(strOut, `alt="`+sf.login+`"`) {
+		if strings.Contains(strOut, `alt="`+сам.логин+`"`) {
 			isFind = true
 			break
 		}
 	}
 	if !isFind { // Свой танк не найден
-		time.Sleep(time.Second * 1)
-		return fmt.Errorf("Health.findHealth(): своё здоровье не найдено")
+		сам.ОтменитьДействие()
+		return fmt.Errorf("Здоровье.здоровьеНайти(): своё здоровье не найдено")
 	}
 	// Свой танк найден, ищем здоровье
 	ind += 11
@@ -248,56 +249,56 @@ func (sf *Health) findHealth() error {
 	strHealth = lstHealth[0]
 	iHealth, err := strconv.Atoi(strHealth)
 	if err != nil {
-		time.Sleep(time.Second * 1)
+		сам.ОтменитьДействие()
 		return fmt.Errorf("Health.findHealth(): здоровье(%v) не число, err=%w", strHealth, err)
 	}
-	sf.setHealth(iHealth)
+	сам.уст(iHealth)
 	return nil
 }
 
-// setHealth -- устанавливает текущее здоровье
-func (sf *Health) setHealth(val int) {
+// уст -- устанавливает текущее здоровье
+func (sf *Здоровье) уст(val int) {
 	if val < 0 {
 		// log._rintf("WARN Health.setHealth(): кривое значение здоровья танка(%v)\n", val)
 		val = 0
 		return
 	}
 
-	if val > sf.full.Get() {
+	if val > sf.здоровПолн.Get() {
 		// log._rintf("WARN Health.setHealth(): кривое текущее здоровье, %v/%v\n", val, sf.full.Get())
-		sf.full.Set(val)
-		sf.temp.Set(val)
-		sf.deltaOld = 0
+		sf.здоровПолн.Set(val)
+		sf.время.Set(val)
+		sf.здоровСтароеДельта = 0
 		sf.ВыстрелБлок().Reset()
-		sf.isRepair.Reset()
+		sf.еслиНадоЛечить.Reset()
 		return
 	}
 
-	delta := sf.temp.Get() - val
+	delta := sf.время.Get() - val
 	if delta > 0 { // Дельта будет больше нуля, если только
-		if delta != sf.deltaOld {
+		if delta != sf.здоровСтароеДельта {
 			// log._rintf("INFO Health.setHealth(): потеря здоровья=%v/%v\n", -delta, val)
-			sf.deltaOld = delta
-			sf.temp.Set(val)
+			sf.здоровСтароеДельта = delta
+			sf.время.Set(val)
 		}
 	}
 
 	switch {
 	case val == 0:
-		sf.temp.Set(0)
-		sf.Отменить()
+		sf.время.Set(0)
+		sf.ОтменитьДействие()
 		return
 	case val <= 500: // Запретить стрельбу
 		sf.ВыстрелБлок().Set() // Установить запрет стрельбы пока слабое здоровье
-		sf.isRepair.Set()
+		sf.еслиНадоЛечить.Set()
 		// log._rintf("WARN Health.setHealth(): низкий уровень здоровья(%v)\n", val)
 		sf.МанёврНадоУст()
 	case val > 500: // Разрешить стрельбы
 		sf.ВыстрелБлок().Reset()
-		sf.isRepair.Reset()
-		if delta > sf.full.Get()*4/10 { // Проверить на критичность падения здоровья на 40%
+		sf.еслиНадоЛечить.Reset()
+		if delta > sf.здоровПолн.Get()*4/10 { // Проверить на критичность падения здоровья на 40%
 			// log._rintf("WARN Health.setHealth(): большая разовая потеря здоровья(%v)\n", delta)
-			sf.isRepair.Set()
+			sf.еслиНадоЛечить.Set()
 			sf.МанёврНадоУст()
 			return
 		}

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

@@ -22,8 +22,8 @@ func NewRepairTime() *RepairTime {
 	return &RepairTime{}
 }
 
-// Get -- возвращает хранимое значение времени
-func (sf *RepairTime) Get() int {
+// Получ -- возвращает хранимое значение времени
+func (sf *RepairTime) Получ() int {
 	sf.block.RLock()
 	defer sf.block.RUnlock()
 	return sf.val
@@ -62,15 +62,15 @@ func (sf *RepairTime) Dec() {
 	}
 }
 
-// IsReady -- возвращает признак готовности восстановления
-func (sf *RepairTime) IsReady() bool {
+// ЕслиГотово -- возвращает признак готовности восстановления
+func (sf *RepairTime) ЕслиГотово() bool {
 	sf.block.RLock()
 	defer sf.block.RUnlock()
 	return sf.val == 0
 }
 
-// IsChange -- возвращает признак изменения здоровья после присвоения
-func (sf *RepairTime) IsChange() bool {
+// ЕслиИзменилось -- возвращает признак изменения здоровья после присвоения
+func (sf *RepairTime) ЕслиИзменилось() bool {
 	sf.block.RLock()
 	defer sf.block.RUnlock()
 	return sf.val == sf.valOld

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

@@ -35,8 +35,8 @@ func (sf *IsManevr) Set() {
 	sf.val = true
 }
 
-// Reset -- сбрасывает хранимое состояние
-func (sf *IsManevr) Reset() {
+// Сброс -- сбрасывает хранимое состояние
+func (sf *IsManevr) Сброс() {
 	sf.block.Lock()
 	defer sf.block.Unlock()
 	sf.val = false

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

@@ -19,35 +19,35 @@ import (
 	Пытается маневрировать после выстрела
 */
 
-// Manevr -- маневрирует после выстрела
-type Manevr struct {
-	types.ИСражеиеДействие                        // FIXME:
-	isNeedManevr           *ismanevr.IsManevr     // Требование выполнить манёвр
-	manevrTime             *repairtime.RepairTime // Время до востановления манёвра
-	chTick                 chan int               // Тики для поиска маневра
+// Манёвр -- маневрирует после выстрела
+type Манёвр struct {
+	types.ИСражениеДействие                        // FIXME:
+	еслиМенёврНадо          *ismanevr.IsManevr     // Требование выполнить манёвр
+	времяЖдать              *repairtime.RepairTime // Время до востановления манёвра
+	chTick                  chan int               // Тики для поиска маневра
 }
 
 // NewManevr -- возвращает новый *Manevr
-func NewManevr(battle types.ИСражеиеДействие) (*Manevr, error) {
+func NewManevr(сражение types.ИСражениеДействие) (*Манёвр, error) {
 	{ // Предусловия
-		if battle == nil {
+		if сражение == nil {
 			return nil, fmt.Errorf("NewManevr(): battle is nil")
 		}
 	}
-	sf := &Manevr{
-		ИСражеиеДействие: battle,
-		isNeedManevr:     ismanevr.NewIsManevr(),
-		manevrTime:       repairtime.NewRepairTime(),
-		chTick:           make(chan int, 1),
+	sf := &Манёвр{
+		ИСражениеДействие: сражение,
+		еслиМенёврНадо:    ismanevr.NewIsManevr(),
+		времяЖдать:        repairtime.NewRepairTime(),
+		chTick:            make(chan int, 1),
 	}
-	_ = sf.manevrTime.Set("0") // При запуске боя есть возможность маневрировать
+	_ = sf.времяЖдать.Set("0") // При запуске боя есть возможность маневрировать
 	go sf.makeTick()
-	go sf.run()
+	go sf.пуск()
 	return sf, nil
 }
 
 // Генерирует тик для уменьшения времени ожидания восстановления возможности манёвра
-func (sf *Manevr) makeTick() {
+func (sf *Манёвр) makeTick() {
 	defer func() {
 		close(sf.chTick)
 		// log._rintf("Manevr.makeTick(): сражение завершено\n")
@@ -57,32 +57,32 @@ func (sf *Manevr) makeTick() {
 		case <-sf.Кнт().Done():
 			return
 		default:
-			if sf.manevrTime.Get() <= 0 {
+			if sf.времяЖдать.Получ() <= 0 {
 				sf.chTick <- 1
 			}
-			sf.manevrTime.Dec()
+			sf.времяЖдать.Dec()
 			time.Sleep(time.Second * 1)
 		}
 	}
 }
 
 // Рабочий цикл поиска маневра (~)
-func (sf *Manevr) run() {
-	for range sf.chTick {
-		if !sf.isNeedManevr.Get() { // Если нет требования манёвра -- пропускаем
+func (сам *Манёвр) пуск() {
+	for range сам.chTick {
+		if !сам.еслиМенёврНадо.Get() { // Если нет требования манёвра -- пропускаем
 			continue
 		}
-		sf.manevr()
-		sf.findManevrTime() // Найти время после манёвра
+		сам.манёвр()
+		сам.времяМанёврНайти() // Найти время после манёвра
 	}
 }
 
 // Ищет время для манёвра
-func (sf *Manevr) findManevrTime() {
+func (сам *Манёвр) времяМанёврНайти() {
 	var (
 		isFind      bool
 		ind         int
-		lstBattleOn = sf.СписПолучить()
+		lstBattleOn = сам.СписПолучить()
 		strOut      string
 	)
 	for ind, strOut = range lstBattleOn {
@@ -94,12 +94,12 @@ func (sf *Manevr) findManevrTime() {
 	}
 	if !isFind { // Или манёвр успел восстановиться, или конец сражения
 		if strings.Contains(strOut, `<span>Маневр</span>`) {
-			_ = sf.manevrTime.Set("0")
+			_ = сам.времяЖдать.Set("0")
 			time.Sleep(time.Second * 1)
 			return
 		}
-		logrus.WithField("strOut", strOut).Warn("Manevr.findManevrTime(): ошибка в поиске времени манёвра")
-		time.Sleep(time.Second * 1)
+		logrus.WithField("strOut", strOut).Warn("Манёвр.времяМанёврНайти(): ошибка в поиске времени манёвра")
+		сам.ОтменитьДействие()
 		return
 	}
 	{ // Найти время манёвра
@@ -110,26 +110,26 @@ func (sf *Manevr) findManevrTime() {
 				WithField("lstBattleOn[ind]", strOut).
 				WithField("lstBattleOn[+1]", lstBattleOn[ind+1]).
 				Errorf("Manevr.findManevrTime(): нет двух полей во времени ожидания")
-			time.Sleep(time.Second * 1)
+			сам.ОтменитьДействие()
 			return
 		}
 		strTime := lstTime[1]
 		lstTime = strings.Split(strTime, ` секунд</span></span></a>`)
 		strTime = lstTime[0]
-		if err := sf.manevrTime.Set(strTime); err != nil {
+		if err := сам.времяЖдать.Set(strTime); err != nil {
 			logrus.WithError(err).Error("Manevr.findManevrTime(): при обновлении времени ожидания манёвра")
-			time.Sleep(time.Second * 1)
+			сам.ОтменитьДействие()
 			return
 		}
 	}
-	logrus.WithField("время", sf.manevrTime.Get()).Info("Manevr.findManevrTime(): до манёвра")
+	logrus.WithField("время", сам.времяЖдать.Получ()).Info("Manevr.findManevrTime(): до манёвра")
 }
 
 // Манёвр по возможности
-func (sf *Manevr) manevr() {
+func (сам *Манёвр) манёвр() {
 	var (
 		isFind      = false
-		lstBattleOn = sf.СписПолучить()
+		lstBattleOn = сам.СписПолучить()
 		strOut      = ""
 	)
 	for _, strOut = range lstBattleOn {
@@ -140,7 +140,6 @@ func (sf *Manevr) manevr() {
 		}
 	}
 	if !isFind { // Либо ждём восстановления манёвра, либо сражение закончилось
-		time.Sleep(time.Second * 1)
 		return
 	}
 	{ // Попытка манёвра
@@ -148,28 +147,28 @@ func (sf *Manevr) manevr() {
 		strLink := lstLink[1]
 		lstLink = strings.Split(strLink, `" class="simple-but blue"><span><span>Маневр</span></span></a>`)
 		strLink = "http://wartank.ru/" + lstLink[0]
-		lstBattleOn, err := sf.Сеть().Get(strLink)
+		lstBattleOn, err := сам.Сеть().Get(strLink)
 		if err != nil {
 			logrus.WithError(err).Error("Manevr.Manevr(): при выполнении GET-команды маневра")
-			time.Sleep(time.Second * 1)
+			сам.ОтменитьДействие()
 			return
 		}
-		if err = sf.СтрОбновить(lstBattleOn); err != nil {
+		if err = сам.СтрОбновить(lstBattleOn); err != nil {
 			logrus.WithError(err).Error("Manevr.Manevr(): при обновлении lstBattle")
-			time.Sleep(time.Second * 1)
+			сам.ОтменитьДействие()
 			return
 		}
 		// sound.Manevr()
 	}
-	sf.isNeedManevr.Reset()
+	сам.еслиМенёврНадо.Сброс()
 }
 
-// IsReady -- возвращает готовность манёвра
-func (sf *Manevr) IsReady() bool {
-	return sf.manevrTime.IsReady()
+// ЕслиГотов -- возвращает готовность манёвра
+func (sf *Манёвр) ЕслиГотов() bool {
+	return sf.времяЖдать.ЕслиГотово()
 }
 
-// SetNeed -- устанавливает признак необходимости манёвра
-func (sf *Manevr) SetNeed() {
-	sf.isNeedManevr.Set()
+// УстНадо -- устанавливает признак необходимости манёвра
+func (sf *Манёвр) УстНадо() {
+	sf.еслиМенёврНадо.Set()
 }

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

@@ -24,18 +24,18 @@ import (
 	Второй параметр меняется медленно (в зависимости от количества очков после выстрела)
 */
 
-// Shot -- объект выстрела
-type Shot struct {
-	types.ИСражеиеДействие                    // FIXME!!!
-	recharge               *shottime.ShotTime // Сколько времени нужно для полной перезарядки
-	damage                 *damage.Damage     // Урон от выстрела с памятью
-	damageSum              alias.ADamage      // Суммарный урон
-	login                  string             // Логин для поиска контрольных строк
-	chTick                 chan int           // Тик для выстрела
+// Выстрел -- объект выстрела
+type Выстрел struct {
+	types.ИСражениеДействие                    // FIXME!!!
+	времяПерезаряд          *shottime.ShotTime // Сколько времени нужно для полной перезарядки
+	урон                    *damage.Damage     // Урон от выстрела с памятью
+	уронВсего               alias.ADamage      // Суммарный урон
+	логин                   string             // Логин для поиска контрольных строк
+	chTick                  chan int           // Тик для выстрела
 }
 
-// NewShot -- возвращает новый *Shot
-func NewShot(battle types.ИСражеиеДействие, login string) (*Shot, error) {
+// НовВыстрел -- возвращает новый *Shot
+func НовВыстрел(battle types.ИСражениеДействие, login string) (*Выстрел, error) {
 	{ // Предусловия
 		if battle == nil {
 			return nil, fmt.Errorf("NewShot(): battle is nil")
@@ -44,33 +44,33 @@ func NewShot(battle types.ИСражеиеДействие, login string) (*Shot
 			return nil, fmt.Errorf("NewShot(): login is empty")
 		}
 	}
-	sf := &Shot{
-		ИСражеиеДействие: battle,
-		recharge:         shottime.NewShotTime(),
-		damage:           damage.NewDamage(),
-		login:            login,
-		chTick:           make(chan int, 2),
+	sf := &Выстрел{
+		ИСражениеДействие: battle,
+		времяПерезаряд:    shottime.NewShotTime(),
+		урон:              damage.NewDamage(),
+		логин:             login,
+		chTick:            make(chan int, 2),
 	}
 	// Установить время перезарядки
-	sf.recharge.Set(6800)
+	sf.времяПерезаряд.Set(6800)
 	go sf.makeTick()
-	go sf.run()
+	go sf.пуск()
 	return sf, nil
 }
 
 // Генерирует тики, когда можно стрелять
-func (sf *Shot) makeTick() {
+func (сам *Выстрел) makeTick() {
 	defer func() {
-		close(sf.chTick)
+		close(сам.chTick)
 		// log._rintf("Shot.makeTick(): сражение завершёно\n")
 	}()
 	for {
 		select {
-		case <-sf.Кнт().Done():
+		case <-сам.Кнт().Done():
 			return
 		default:
-			sf.chTick <- 1 // Первый выстрел, потом спать по таймингу
-			recharge := sf.recharge.Get()
+			сам.chTick <- 1 // Первый выстрел, потом спать по таймингу
+			recharge := сам.времяПерезаряд.Get()
 			// log._rintf("INFO Shot.run() перезарядка=%v msec\n", recharge)
 			// Если идёт перезарядка -- постепенно обнуляем время ожидания
 			time.Sleep(time.Millisecond * time.Duration(recharge))
@@ -79,30 +79,31 @@ func (sf *Shot) makeTick() {
 }
 
 // Цикл выстрела (в отдельном потоке)
-func (sf *Shot) run() {
-	for range sf.chTick {
-		if sf.ВыстрелБлок().Get() { // Стрелять нельзя
+func (сам *Выстрел) пуск() {
+	for range сам.chTick {
+		if сам.ВыстрелБлок().Get() { // Стрелять нельзя
 			continue
 		}
 		// Стрелять можно, стандартное ожидание
-		sf.shot()
-		sf.findDamage()
+		сам.выстрел()
+		сам.найтиУрон()
 	}
 }
 
 // Обновляет возможность выстрела (~)
 //
 //	Вызывается из отдельного потока
-func (sf *Shot) shot() {
-	if err := sf.Сеть().UpdateLst(); err != nil { // Проверка на непосредственно битву
+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 = sf.СписПолучить()
+		lstBattle = сам.СписПолучить()
 		isFind    bool
 		err       error
 	)
@@ -115,40 +116,40 @@ func (sf *Shot) shot() {
 	}
 	if !isFind {
 		// log._rintf("WARN Shot.shot(): не найдены ссылка на выстрел\n")
-		time.Sleep(time.Second * 1)
+		сам.ОтменитьДействие()
 		return
 	}
 	lstLink := strings.Split(strOut, `<a href="`)
 	strLink := lstLink[1]
 	lstLink = strings.Split(strLink, `" class="simple-but gray"><span><span>ОБЫЧНЫЕ</span></span></a>`)
 	strLink = "http://wartank.ru/" + lstLink[0]
-	lstBattle, err = sf.Сеть().Get(strLink)
+	lstBattle, err = сам.Сеть().Get(strLink)
 	if err != nil {
 		// log._rintf("ERRO Shot.shot(): при исполнении GET-команды выстрела обычным снарядом, err=\n\t%v\n", err)
-		time.Sleep(time.Second * 1)
+		сам.ОтменитьДействие()
 		return
 	}
-	if err = sf.СтрОбновить(lstBattle); err != nil {
+	if err = сам.СтрОбновить(lstBattle); err != nil {
 		// log._rintf("ERRO Shot.shot(): при обновлении lstBattle, err=\n\t%v\n", err)
-		time.Sleep(time.Second * 1)
+		сам.ОтменитьДействие()
 		return
 	}
-	sf.МанёврНадоУст()
+	сам.МанёврНадоУст()
 	// sound.Shot()
 }
 
 // Ищет урон от выстрела
-func (sf *Shot) findDamage() {
+func (сам *Выстрел) найтиУрон() {
 	var (
 		ind     = 0
 		isFind  = false
-		lstShot = sf.СписПолучить()
+		lstShot = сам.СписПолучить()
 		strOut  string
 	)
 
 	for ind, strOut = range lstShot {
 		// <span class="yellow1 td_u">prospero tank</span>
-		if strings.Contains(strOut, `<span class="yellow1 td_u">`+sf.login+`</span>`) {
+		if strings.Contains(strOut, `<span class="yellow1 td_u">`+сам.логин+`</span>`) {
 			ind += 2
 			strOut = lstShot[ind]
 			isFind = true
@@ -162,44 +163,42 @@ func (sf *Shot) findDamage() {
 	}
 	lstDamage := strings.Split(strOut, ` на  <span class="red1">`)
 	if len(lstDamage) == 1 {
-		time.Sleep(time.Second * 1)
 		return
 	}
 	strDamage := lstDamage[1]
 	iDamage, err := strconv.Atoi(strDamage)
 	if err != nil {
 		// log._rintf("ERRO Shot.findDamage(): damage(%v) не число, err=\n\t%v\n", strDamage, err)
-		time.Sleep(time.Second * 1)
+		сам.ОтменитьДействие()
 		return
 	}
 	if iDamage <= 0 { // Кривой урон от выстрела
-		sf.recharge.Dec5()
+		сам.времяПерезаряд.Dec5()
 		// log._rintf("WARN Shot.findDamage(): ошибка в значении урона(%v)\n", iDamage)
 		iDamage = 0
 	}
-	sf.damageSum += alias.ADamage(iDamage)
+	сам.уронВсего += alias.ADamage(iDamage)
 	// log._rintf("INFO Shot.Damage(): damageSum=%v\n", sf.damageSum)
 	if iDamage < 70 {
-		sf.damage.Set(alias.ADamage(iDamage))
-		sf.recharge.Inc210()
+		сам.урон.Set(alias.ADamage(iDamage))
+		сам.времяПерезаряд.Inc210()
 	}
 	// log._rintf("INFO Shot.findDamage(): выстрел=+%v, урон=%v", iDamage, sf.damageSum)
 	if iDamage == 0 {
-		time.Sleep(time.Second * 1)
 		return
 	}
-	sf.setDamage(alias.ADamage(iDamage))
+	сам.setDamage(alias.ADamage(iDamage))
 }
 
 // setDamage -- обновляет время перезарядки в зависимости от произведённого урона
-func (sf *Shot) setDamage(val alias.ADamage) {
-	sf.damage.Set(val)
-	switch sf.damage.Result() {
+func (sf *Выстрел) setDamage(val alias.ADamage) {
+	sf.урон.Set(val)
+	switch sf.урон.Result() {
 	case "none":
-		sf.recharge.Dec5()
+		sf.времяПерезаряд.Dec5()
 	case "up":
-		sf.recharge.Dec30()
+		sf.времяПерезаряд.Dec30()
 	case "down":
-		sf.recharge.Inc210()
+		sf.времяПерезаряд.Inc210()
 	}
 }