d04 Рефакторинг

main.py

@@ -1,3 +1,4 @@
+#!/usr/bin/python3
 """Главный файл работы с клиентом бото-фермы"""
 
 from pakApp.modApp import App

pakApp/pakGui/pakWinState/modWinState.py

@@ -3,13 +3,15 @@
 from typing import Any
 from tkinter import Toplevel, LabelFrame, Label, Frame, Button
 
+from pakApp.pakGui.pakWinState.pakFrmShahta.modFrmShahta import FrmShahta
+
 
 class WinState(Toplevel):
     """Окно состояния бота"""
 
     def __init__(self, win_main: Any, name_bot: str) -> None:
         Toplevel.__init__(self, master=win_main)
-        self.title("Стаистика бта: "+name_bot)
+        self.title("Статистика бота: "+name_bot)
         self.geometry("800x600")
         self.win_main = win_main
         self.name = name_bot
@@ -135,12 +137,7 @@ class WinState(Toplevel):
                                    relief="sunken")
         self.frm_basa.pack(side="top", fill="x")
 
-        self.lbl_shahta = Label(self.frm_basa,
-                                text="Шахта: 0",
-                                border=3,
-                                relief="ridge",
-                                anchor="w")
-        self.lbl_shahta.pack(side="top", fill="x")
+        self.frm_shahta = FrmShahta(self.frm_basa)
 
         self.auto_update()
 
@@ -162,7 +159,7 @@ class WinState(Toplevel):
         self.lbl_tochnost["text"] = "Точность: " + res["точность"]
         self.lbl_prochnost["text"] = "Прочность: " + res["прочность"]
         self.lbl_mosh["text"] = "Танковая мощь: " + res["мощь"]
-        self.lbl_shahta["text"] = "Шахта: уровень=" + res["шахта_уровень"]
+        self.frm_shahta.upstat(res)
 
     def close(self):
         """Закрывает окно по требованию"""

pakApp/pakGui/pakWinState/pakFrmShahta/modFrmShahta.py

@@ -0,0 +1,51 @@
+"""Фрейм для отображения состояния шахты"""
+
+from typing import Any
+from tkinter import LabelFrame, Label
+
+
+class FrmShahta(LabelFrame):
+    """Фрейм для отображения состояния шахты на базе"""
+
+    def __init__(self, frm_basa: Any) -> None:
+        LabelFrame.__init__(self,
+                            master=frm_basa,
+                            text="шахта",
+                            border=3,
+                            relief="sunken")
+        self.pack(side="left")
+
+        self.lbl_level = Label(self,
+                               text="Уровень: 0",
+                               border=3,
+                               relief="ridge",
+                               anchor="w")
+        self.lbl_level.pack(side="top", fill="x")
+
+        self.lbl_kol = Label(self,
+                             text="Режим: -",
+                             border=3,
+                             relief="ridge",
+                             anchor="w")
+        self.lbl_kol.pack(side="top", fill="x")
+
+        self.lbl_nazv = Label(self,
+                              text="Название: -",
+                              border=3,
+                              relief="ridge",
+                              anchor="w")
+        self.lbl_nazv.pack(side="top", fill="x")
+
+        self.lbl_vrema = Label(self,
+                               text="Время: -",
+                               border=3,
+                               relief="ridge",
+                               anchor="w")
+        self.lbl_vrema.pack(side="top", fill="x")
+
+    def upstat(self, src) -> None:
+        """Обновляет состояние шахты на базе"""
+        self.lbl_level["text"] = "Уровень: " + src["шахта_уровень"]
+        self.lbl_kol["text"] = "Режим: " + src["шахта_сделать_кол"]
+        self.lbl_nazv["text"] = "Название: " + src["шахта_сделать_назв"]
+        self.lbl_vrema["text"] = "Время: " + src["шахта_сделать_время"]

pkg/alias/alias.go

@@ -4,11 +4,14 @@ package alias
 	Содержит алиасы типов, необходимые для работы.
 */
 
-// AMilSec -- время в миллисекундах
-type AMilSec int
+// МилСек -- время в миллисекундах
+type МилСек int
 
 // ADAmage -- урон от выстрела
-type ADamage int
+type Урон int
 
-// ИмяОкно -- имя окно показа
+// ОкноИмя -- имя окно показа
 type ОкноИмя string
+
+// Час -- количество часов
+type Час uint

pkg/components/kernel/slog/slog.go

@@ -8,7 +8,7 @@ import (
 
 	"wartank/pkg/components/kernel/slog/slog_file"
 	"wartank/pkg/components/kernel/slog/slog_term"
-	"wartank/pkg/components/safebool"
+	"wartank/pkg/components/safe_bool"
 	"wartank/pkg/cons"
 	"wartank/pkg/types"
 )
@@ -32,7 +32,7 @@ type Slog struct {
 	block  sync.RWMutex
 	lf     *slog_file.SlogFile
 	lt     *slog_term.SlogTerm
-	isWork *safebool.SafeBool
+	isWork *safe_bool.БезопБул
 	level  int // Уровень логирования
 }
 
@@ -45,7 +45,7 @@ func NewSlog(kern types.IKernel) (*Slog, error) {
 		kern:   kern,
 		buf:    strings.Builder{},
 		lt:     slog_term.NewSlogTerm(),
-		isWork: safebool.NewSafeBool(),
+		isWork: safe_bool.НовБезопБул(),
 		level:  LevelDebug,
 	}
 	lf, err := slog_file.NewSlogFile(kern, "test")

pkg/components/kernel/slog/slog_file/slog_file.go

@@ -8,7 +8,7 @@ import (
 	"sync"
 	"time"
 
-	"wartank/pkg/components/safebool"
+	"wartank/pkg/components/safe_bool"
 	"wartank/pkg/cons"
 	"wartank/pkg/types"
 )
@@ -22,7 +22,7 @@ type SlogFile struct {
 	kern     types.IKernel
 	file     *os.File
 	fileName string
-	isWork   *safebool.SafeBool
+	isWork   *safe_bool.БезопБул
 	chMsg    chan []byte // канал входящих сообщений
 	block    sync.Mutex
 }
@@ -40,7 +40,7 @@ func NewSlogFile(kern types.IKernel, build string) (*SlogFile, error) {
 	sf := &SlogFile{
 		kern:     kern,
 		fileName: cons.SelfName + "_" + build + time.Now().UTC().Format("_2006-01-02 15:04:05.000") + ".log",
-		isWork:   safebool.NewSafeBool(),
+		isWork:   safe_bool.НовБезопБул(),
 		chMsg:    make(chan []byte, 10),
 	}
 	sf.isWork.Уст()

pkg/components/kernel/wgname/wgname.go

@@ -5,14 +5,14 @@ import (
 	"fmt"
 	"sync"
 
-	"wartank/pkg/components/safebool"
+	"wartank/pkg/components/safe_bool"
 )
 
 // WgName -- ожидатель группы завершения
 type WgName struct {
-	dictName map[string]bool    // Словарь имён потоков
-	chEnd    chan int           // Канал сигнала закрытия ожидания
-	isWork   *safebool.SafeBool // Признак работы ожидания
+	dictName map[string]bool     // Словарь имён потоков
+	chEnd    chan int            // Канал сигнала закрытия ожидания
+	isWork   *safe_bool.БезопБул // Признак работы ожидания
 	block    sync.RWMutex
 }
 
@@ -21,7 +21,7 @@ func NewWgName() *WgName {
 	sf := &WgName{
 		dictName: make(map[string]bool),
 		chEnd:    make(chan int, 1),
-		isWork:   safebool.NewSafeBool(),
+		isWork:   safe_bool.НовБезопБул(),
 	}
 	sf.isWork.Уст()
 	return sf

pkg/components/parser_time/parse_hour/parse_hour.go

@@ -0,0 +1,83 @@
+package parse_hour
+
+import (
+	"fmt"
+	"strconv"
+	"sync"
+	"wartank/pkg/alias"
+	"wartank/pkg/types"
+)
+
+/*
+	Потокобезопасно парсит из строки значение часа
+*/
+
+// ПарсерЧас -- потокобезопасный парсер часа из строки
+type ПарсерЧас struct {
+	знач alias.Час // Значение часа
+	блок sync.RWMutex
+}
+
+// НовПарсерЧас -- возвращает новый *ПарсерЧас
+func НовПарсерЧас() *ПарсерЧас {
+	сам := &ПарсерЧас{}
+	_ = types.ИПарсерЧас(сам)
+	return сам
+}
+
+// Получ -- возвращает хранимое значение
+func (сам *ПарсерЧас) Получ() alias.Час {
+	сам.блок.RLock()
+	defer сам.блок.RUnlock()
+	return сам.знач
+}
+
+// String -- возвращает строковое значение часов
+func (сам *ПарсерЧас) String() string {
+	сам.блок.RLock()
+	defer сам.блок.RUnlock()
+	res := fmt.Sprintf("%02d", сам.знач)
+	return res
+}
+
+// Сброс -- сбрасывает значение часов
+func (сам *ПарсерЧас) Сброс() {
+	сам.блок.Lock()
+	defer сам.блок.Unlock()
+	сам.знач = 0
+}
+
+// Уст -- устанавливает значение часов
+//
+//	Значение часов может быть больше 24
+func (sf *ПарсерЧас) Уст(часы string) error {
+	sf.блок.Lock()
+	defer sf.блок.Unlock()
+	цЧасы, err := strconv.Atoi(часы)
+	if err != nil {
+		return fmt.Errorf("ПарсерЧас.Уст(): часы(%q) не число, err=\n\t%w", часы, err)
+	}
+	if цЧасы<0{
+		return fmt.Errorf("ПарсерЧас.Уст(): часы(%q) меньше нуля, err=\n\t%w", часы, err)
+	}
+	if err := sf.уст(alias.Час(цЧасы)); err != nil {
+		return fmt.Errorf("ПарсерЧас.Уст(): in internal set hour(%q), err=\n\t%w", часы, err)
+	}
+	return nil
+}
+
+// УстЦел -- устанавливает числовое значение часов
+func (sf *ПарсерЧас) УстЦел(часы alias.Час) error {
+	sf.блок.Lock()
+	defer sf.блок.Unlock()
+	if err := sf.уст(часы); err != nil {
+		return fmt.Errorf("ПарсерЧас.УстЦел(): in internal set hour(%v), err=\n\t%w", часы, err)
+	}
+	return nil
+}
+
+// Внутренняя процедура для числовой установки часов без блокировки
+func (sf *ПарсерЧас) уст(часы alias.Час) error {
+	sf.знач = часы
+	return nil
+}

pkg/components/parsetime/parsehour/parsehour_test.go → pkg/components/parser_time/parse_hour/parse_hour_test.go

@@ -1,4 +1,4 @@
-package parsehour
+package parse_hour
 
 import (
 	"testing"
@@ -11,7 +11,7 @@ import (
 // Тестер для проверки парсера времени
 type tester struct {
 	t  *testing.T
-	ph *ParseHour
+	ph *ПарсерЧас
 }
 
 func TestParseHour(t *testing.T) {
@@ -27,7 +27,7 @@ func TestParseHour(t *testing.T) {
 // Сброс часов в ноль
 func (sf *tester) reset() {
 	sf.t.Logf("=reset=\n")
-	sf.ph.Reset()
+	sf.ph.Сброс()
 	if strHour := sf.ph.String(); strHour != "00" {
 		sf.t.Errorf("setGood2(): strHour(%q)!='00'\n", strHour)
 	}
@@ -41,7 +41,7 @@ func (sf *tester) set() {
 }
 func (sf *tester) setGood1() {
 	sf.t.Logf("=setGood1=\n")
-	if err := sf.ph.Set(8); err != nil {
+	if err := sf.ph.Уст("8"); err != nil {
 		sf.t.Errorf("setGood1(): err=\n\t%v\n", err)
 	}
 }
@@ -49,7 +49,7 @@ func (sf *tester) setGood1() {
 // Отрицательное значение часа
 func (sf *tester) setBad1() {
 	sf.t.Logf("=setBad1=\n")
-	if err := sf.ph.Set(-1); err == nil {
+	if err := sf.ph.Уст("-1"); err == nil {
 		sf.t.Errorf("setBad1(): err==nil\n")
 	}
 }
@@ -66,7 +66,7 @@ func (sf *tester) parse() {
 // Установка правильных большихчасов
 func (sf *tester) parseGood2() {
 	sf.t.Logf("=parseGood2=\n")
-	if err := sf.ph.Parse("867"); err != nil {
+	if err := sf.ph.Уст("867"); err != nil {
 		sf.t.Errorf("parseGood2(): err=\n\t%v\n", err)
 	}
 	if strHour := sf.ph.String(); strHour != "867" {
@@ -77,7 +77,7 @@ func (sf *tester) parseGood2() {
 // Установка правильных часов
 func (sf *tester) parseGood1() {
 	sf.t.Logf("=parseGood1=\n")
-	if err := sf.ph.Parse("8"); err != nil {
+	if err := sf.ph.Уст("8"); err != nil {
 		sf.t.Errorf("parseGood1(): err=\n\t%v\n", err)
 	}
 	if strHour := sf.ph.String(); strHour != "08" {
@@ -88,7 +88,7 @@ func (sf *tester) parseGood1() {
 // Установка отрицательных часов
 func (sf *tester) parseBad2() {
 	sf.t.Logf("=parseBad2=\n")
-	if err := sf.ph.Parse("-1"); err == nil {
+	if err := sf.ph.Уст("-1"); err == nil {
 		sf.t.Errorf("parseBad2(): err==nil\n")
 	}
 }
@@ -96,7 +96,7 @@ func (sf *tester) parseBad2() {
 // Установка не часов
 func (sf *tester) parseBad1() {
 	sf.t.Logf("=parseBad1=\n")
-	if err := sf.ph.Parse("abc"); err == nil {
+	if err := sf.ph.Уст("abc"); err == nil {
 		sf.t.Errorf("parseBad1(): err==nil\n")
 	}
 }
@@ -104,11 +104,11 @@ func (sf *tester) parseBad1() {
 // Создание парсера часов
 func (sf *tester) create() {
 	sf.t.Logf("=create=\n")
-	sf.ph = NewParseHour()
+	sf.ph = НовПарсерЧас()
 	if sf.ph == nil {
 		sf.t.Errorf("create(): parseHour==nil\n")
 	}
-	if hour := sf.ph.Get(); hour != 0 {
+	if hour := sf.ph.Получ(); hour != 0 {
 		sf.t.Errorf("create(): hour(%v)!=0\n", hour)
 	}
 	if strHour := sf.ph.String(); strHour != "00" {

pkg/components/parser_time/parser_time.go

@@ -0,0 +1,109 @@
+package parser_time
+
+import (
+	"fmt"
+	"strings"
+	"sync"
+
+	"wartank/pkg/components/parser_time/parse_hour"
+	"wartank/pkg/components/parser_time/parsemin"
+	"wartank/pkg/components/parser_time/parsesec"
+	"wartank/pkg/types"
+)
+
+/*
+	Выковыривает из строки время и потокобезопасно хранит его
+*/
+
+// ПарсерВремя -- потокобезопасный ковырятор строки времени
+type ПарсерВремя struct {
+	всегоСек int                // Числовое значение хранимого времени
+	час      types.ИПарсерЧас   // Часы метки времени
+	мин      *parsemin.ParseMin // Минуты метки времени
+	сек      *parsesec.ParseSec // Секунды метки времени
+
+	block sync.RWMutex
+}
+
+// НовПарсерВремя -- возвращает новый *ParseTime
+func НовПарсерВремя() *ПарсерВремя {
+	сам := &ПарсерВремя{
+		час: parse_hour.НовПарсерЧас(),
+		мин: parsemin.NewParseMin(),
+		сек: parsesec.NewParseSec(),
+	}
+	_ = types.ИПарсерВремя(сам)
+	return сам
+}
+
+// ВсегоСек -- возвращает общее число секунд
+func (sf *ПарсерВремя) ВсегоСек() int {
+	sf.block.RLock()
+	defer sf.block.RUnlock()
+	return sf.всегоСек
+}
+
+// Уст -- разбирает строковое представление на части
+func (sf *ПарсерВремя) Уст(strTime string) error {
+	sf.block.Lock()
+	defer sf.block.Unlock()
+	if strTime == "" {
+		return fmt.Errorf("CountTime.Set(): val is empty")
+	}
+	// Разбить время, перевести в секунды
+	lstTime := strings.Split(strTime, ":")
+	switch len(lstTime) {
+	case 1: // Только секунды
+		sf.час.Сброс()
+		sf.мин.Reset()
+		if err := sf.сек.Parse(lstTime[0]); err != nil {
+			return fmt.Errorf("ParseTime(): in parse second only, err=\n\t%w", err)
+		}
+	case 2: // Минуты, секунды
+		sf.час.Сброс()
+		if err := sf.мин.Parse(lstTime[0]); err != nil {
+			return fmt.Errorf("ParseTime(): in parse [min]/sec, err=\n\t%w", err)
+		}
+		if err := sf.сек.Parse(lstTime[1]); err != nil {
+			return fmt.Errorf("ParseTime(): in parse min/[sec], err=\n\t%w", err)
+		}
+	case 3:
+		strHour := lstTime[0]
+		strMin := lstTime[1]
+		strSec := lstTime[2]
+		if err := sf.сек.Parse(strSec); err != nil {
+			return fmt.Errorf("ParseTime(): in parse hour/min/[sec], err=\n\t%w", err)
+		}
+		if err := sf.мин.Parse(strMin); err != nil {
+			return fmt.Errorf("ParseTime(): in parse hour/[min]/sec, err=\n\t%w", err)
+		}
+		if err := sf.час.Уст(strHour); err != nil {
+			return fmt.Errorf("ParseTime(): in parse [hour]/min/sec, err=\n\t%w", err)
+		}
+	default:
+		return fmt.Errorf("ParseTime(): bad time val(%q)", strTime)
+	}
+	sf.всегоСек = int(sf.час.Получ()*3600) + sf.мин.Get()*60 + sf.сек.Get()
+	return nil
+}
+
+// Hour -- возвращает хранимые часы
+func (sf *ПарсерВремя) Час() types.ИПарсерЧас {
+	return sf.час
+}
+
+// Min -- возвращает хранимые минуты
+func (sf *ПарсерВремя) Min() *parsemin.ParseMin {
+	return sf.мин
+}
+
+// Sec -- возвращает хранимые секунды
+func (sf *ПарсерВремя) Sec() *parsesec.ParseSec {
+	return sf.сек
+}
+
+// String -- возвращает хранимое время
+func (sf *ПарсерВремя) String() string {
+	res := sf.час.String() + ":" + sf.мин.String() + ":" + sf.сек.String()
+	return res
+}

pkg/components/parsetime/parsetime_test.go → pkg/components/parser_time/parser_time_test.go

@@ -1,4 +1,4 @@
-package parsetime
+package parser_time
 
 import (
 	"testing"
@@ -11,7 +11,7 @@ import (
 // Тестер для парсера времени
 type tester struct {
 	t    *testing.T
-	pars *ParseTime
+	pars *ПарсерВремя
 }
 
 func TestParseTime(t *testing.T) {
@@ -25,17 +25,17 @@ func TestParseTime(t *testing.T) {
 // Создание парсера
 func (sf *tester) create() {
 	sf.t.Logf("=create=\n")
-	sf.pars = NewParseTime()
-	if sf.pars.hour == nil {
+	sf.pars = НовПарсерВремя()
+	if sf.pars.час == nil {
 		sf.t.Errorf("create(): hour==nil\n")
 	}
-	if sf.pars.min == nil {
+	if sf.pars.мин == nil {
 		sf.t.Errorf("create(): min==nil\n")
 	}
-	if sf.pars.sec == nil {
+	if sf.pars.сек == nil {
 		sf.t.Errorf("create(): sec==nil\n")
 	}
-	if val := sf.pars.Get(); val != 0 {
+	if val := sf.pars.ВсегоСек(); val != 0 {
 		sf.t.Errorf("create(): valInt(%d)!=0\n", val)
 	}
 	_ = sf.pars.String()
@@ -58,13 +58,13 @@ func (sf *tester) parse() {
 
 func (sf *tester) parseHourHourBad1() {
 	sf.t.Logf("=parseHourHourBad1=\n")
-	if err := sf.pars.Parse("-11:14:54"); err == nil {
+	if err := sf.pars.Уст("-11:14:54"); err == nil {
 		sf.t.Errorf("parseHourHourBad1(): err==nil\n")
 	}
-	if val := sf.pars.Get(); val != 5820 {
+	if val := sf.pars.ВсегоСек(); val != 5820 {
 		sf.t.Errorf("parseHourHourBad1(): valInt(%d)!=5820\n", val)
 	}
-	if hour := sf.pars.Hour().Get(); hour != 1 {
+	if hour := sf.pars.Час().Получ(); hour != 1 {
 		sf.t.Errorf("parseHourHourBad1(): hour(%d)!=1\n", hour)
 	}
 	if min := sf.pars.Min().Get(); min != 14 {
@@ -77,60 +77,60 @@ func (sf *tester) parseHourHourBad1() {
 
 func (sf *tester) parseHourMinBad1() {
 	sf.t.Logf("=parseHourMinBad1=\n")
-	if err := sf.pars.Parse("01:-4:01"); err == nil {
+	if err := sf.pars.Уст("01:-4:01"); err == nil {
 		sf.t.Errorf("parseHourMinBad1(): err==nil\n")
 	}
-	if val := sf.pars.Get(); val != 5820 {
+	if val := sf.pars.ВсегоСек(); val != 5820 {
 		sf.t.Errorf("parseHourMinBad1(): valInt(%d)!=5820\n", val)
 	}
 }
 
 func (sf *tester) parseHourSecBad1() {
 	sf.t.Logf("=parseHourSecBad1=\n")
-	if err := sf.pars.Parse("01:37:a"); err == nil {
+	if err := sf.pars.Уст("01:37:a"); err == nil {
 		sf.t.Errorf("parseHourSecBad1(): err==nil\n")
 	}
-	if val := sf.pars.Get(); val != 5820 {
+	if val := sf.pars.ВсегоСек(); val != 5820 {
 		sf.t.Errorf("parseHourSecBad1(): valInt(%d)!=5820\n", val)
 	}
 }
 
 func (sf *tester) parseHour() {
 	sf.t.Logf("=parseHour=\n")
-	if err := sf.pars.Parse("01:37:00"); err != nil {
+	if err := sf.pars.Уст("01:37:00"); err != nil {
 		sf.t.Errorf("parseHour(): err=\n\t%v\n", err)
 	}
-	if val := sf.pars.Get(); val != 5820 {
+	if val := sf.pars.ВсегоСек(); val != 5820 {
 		sf.t.Errorf("parseHour(): valInt(%d)!=5820\n", val)
 	}
 }
 
 func (sf *tester) parseMinMinBad1() {
 	sf.t.Logf("=parseMinMinBad1=\n")
-	if err := sf.pars.Parse("60:25"); err == nil {
+	if err := sf.pars.Уст("60:25"); err == nil {
 		sf.t.Errorf("parseMinMinBad1(): err==nil\n")
 	}
-	if val := sf.pars.Get(); val != 444 {
+	if val := sf.pars.ВсегоСек(); val != 444 {
 		sf.t.Errorf("parseMinMinBad1(): valInt(%d)!=444\n", val)
 	}
 }
 
 func (sf *tester) parseMinSecBad1() {
 	sf.t.Logf("=parseMinSecBad1=\n")
-	if err := sf.pars.Parse("07:-1"); err == nil {
+	if err := sf.pars.Уст("07:-1"); err == nil {
 		sf.t.Errorf("parseMinSecBad1(): err==nil\n")
 	}
-	if val := sf.pars.Get(); val != 7*60+24 {
+	if val := sf.pars.ВсегоСек(); val != 7*60+24 {
 		sf.t.Errorf("parseMinSecBad1(): valInt(%d)!=7*60+24\n", val)
 	}
 }
 
 func (sf *tester) parseMin() {
 	sf.t.Logf("=parseMin=\n")
-	if err := sf.pars.Parse("07:24"); err != nil {
+	if err := sf.pars.Уст("07:24"); err != nil {
 		sf.t.Errorf("parseMin(): err=\n\t%v\n", err)
 	}
-	if val := sf.pars.Get(); val != 7*60+24 {
+	if val := sf.pars.ВсегоСек(); val != 7*60+24 {
 		sf.t.Errorf("parseMin(): valInt(%d)!=7*60+24\n", val)
 	}
 }
@@ -138,20 +138,20 @@ func (sf *tester) parseMin() {
 // Слишком большие секунды
 func (sf *tester) parseSecBad1() {
 	sf.t.Logf("=parseSecBad1=\n")
-	if err := sf.pars.Parse("60"); err == nil {
+	if err := sf.pars.Уст("60"); err == nil {
 		sf.t.Errorf("parseSecBad1(): err==nil\n")
 	}
-	if val := sf.pars.Get(); val != 28 {
+	if val := sf.pars.ВсегоСек(); val != 28 {
 		sf.t.Errorf("parseSecBad1(): valInt(%d)!=28\n", val)
 	}
 }
 
 func (sf *tester) parseSec() {
 	sf.t.Logf("=parseSec=\n")
-	if err := sf.pars.Parse("28"); err != nil {
+	if err := sf.pars.Уст("28"); err != nil {
 		sf.t.Errorf("parseSec(): err=\n\t%v\n", err)
 	}
-	if val := sf.pars.Get(); val != 28 {
+	if val := sf.pars.ВсегоСек(); val != 28 {
 		sf.t.Errorf("parseSec(): valInt(%d)!=28\n", val)
 	}
 }
@@ -159,7 +159,7 @@ func (sf *tester) parseSec() {
 // Нет строки для парсинга
 func (sf *tester) parseBad1() {
 	sf.t.Logf("=parseBad1=\n")
-	if err := sf.pars.Parse(""); err == nil {
+	if err := sf.pars.Уст(""); err == nil {
 		sf.t.Errorf("parseBad1(): err==nil\n")
 	}
 }

pkg/components/parsetime/parsehour/parsehour.go

@@ -1,79 +0,0 @@
-package parsehour
-
-import (
-	"fmt"
-	"strconv"
-	"sync"
-)
-
-/*
-	Потокобезопасно парсит из строки значение часа
-*/
-
-// ParseHour -- потокобезопасный парсер часа из строки
-type ParseHour struct {
-	val   int // Значение часа
-	block sync.RWMutex
-}
-
-// NewParseHour -- возвращает новый *ParseHour
-func NewParseHour() *ParseHour {
-	return &ParseHour{}
-}
-
-// Get -- возвращает хранимое значение
-func (sf *ParseHour) Get() int {
-	sf.block.RLock()
-	defer sf.block.RUnlock()
-	return sf.val
-}
-
-// String -- возвращает строковое значение часов
-func (sf *ParseHour) String() string {
-	sf.block.RLock()
-	defer sf.block.RUnlock()
-	res := fmt.Sprintf("%02d", sf.val)
-	return res
-}
-
-// Reset -- сбрасывает значение часов
-func (sf *ParseHour) Reset() {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	sf.val = 0
-}
-
-// Parse -- устанавливает значение часов
-//
-//	Значение часов может быть больше 24
-func (sf *ParseHour) Parse(strHour string) error {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	iHour, err := strconv.Atoi(strHour)
-	if err != nil {
-		return fmt.Errorf("ParseHour.Parse(): часы(%q) не число, err=\n\t%w", strHour, err)
-	}
-	if err := sf.set(iHour); err != nil {
-		return fmt.Errorf("ParseHour.Parse(): in internal set hour(%q), err=\n\t%w", strHour, err)
-	}
-	return nil
-}
-
-// Set -- устанавливает числовое значение часов
-func (sf *ParseHour) Set(iHour int) error {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	if err := sf.set(iHour); err != nil {
-		return fmt.Errorf("ParseHour.Set(): in internal set hour(%v), err=\n\t%w", iHour, err)
-	}
-	return nil
-}
-
-// Внутренняя процедура для числовой установки часов без блокировки
-func (sf *ParseHour) set(iHour int) error {
-	if iHour < 0 {
-		return fmt.Errorf("ParseHour.set(): часы(%v) < 0", iHour)
-	}
-	sf.val = iHour
-	return nil
-}

pkg/components/parsetime/parsetime.go

@@ -1,105 +0,0 @@
-package parsetime
-
-import (
-	"fmt"
-	"strings"
-	"sync"
-
-	"wartank/pkg/components/parsetime/parsehour"
-	"wartank/pkg/components/parsetime/parsemin"
-	"wartank/pkg/components/parsetime/parsesec"
-)
-
-/*
-	Выковыривает из строки время и потокобезопасно хранит его
-*/
-
-// ParseTime -- потокобезопасный ковырятор строки времени
-type ParseTime struct {
-	intVal int                  // Числовое значение хранимого времени
-	hour   *parsehour.ParseHour // Часы метки времени
-	min    *parsemin.ParseMin   // Минуты метки времени
-	sec    *parsesec.ParseSec   // Секунды метки времени
-
-	block sync.RWMutex
-}
-
-// NewParseTime -- возвращает новый *ParseTime
-func NewParseTime() *ParseTime {
-	return &ParseTime{
-		hour: parsehour.NewParseHour(),
-		min:  parsemin.NewParseMin(),
-		sec:  parsesec.NewParseSec(),
-	}
-}
-
-// GetInt -- возвращает хранимоесчётчика времени
-func (sf *ParseTime) Get() int {
-	sf.block.RLock()
-	defer sf.block.RUnlock()
-	return sf.intVal
-}
-
-// Parse -- разбирает строковое представление на части
-func (sf *ParseTime) Parse(strTime string) error {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	if strTime == "" {
-		return fmt.Errorf("CountTime.Set(): val is empty")
-	}
-	// Разбить время, перевести в секунды
-	lstTime := strings.Split(strTime, ":")
-	if len(lstTime) == 1 { // Только секунды
-		sf.hour.Reset()
-		sf.min.Reset()
-		if err := sf.sec.Parse(lstTime[0]); err != nil {
-			return fmt.Errorf("ParseTime(): in parse second only, err=\n\t%w", err)
-		}
-	}
-	if len(lstTime) == 2 { // Минуты, секунды
-		sf.hour.Reset()
-		if err := sf.min.Parse(lstTime[0]); err != nil {
-			return fmt.Errorf("ParseTime(): in parse [min]/sec, err=\n\t%w", err)
-		}
-		if err := sf.sec.Parse(lstTime[1]); err != nil {
-			return fmt.Errorf("ParseTime(): in parse min/[sec], err=\n\t%w", err)
-		}
-	}
-	if len(lstTime) >= 3 { // Есть всё, возможно с левыми полями в конце
-		strHour := lstTime[0]
-		strMin := lstTime[1]
-		strSec := lstTime[2]
-		if err := sf.sec.Parse(strSec); err != nil {
-			return fmt.Errorf("ParseTime(): in parse hour/min/[sec], err=\n\t%w", err)
-		}
-		if err := sf.min.Parse(strMin); err != nil {
-			return fmt.Errorf("ParseTime(): in parse hour/[min]/sec, err=\n\t%w", err)
-		}
-		if err := sf.hour.Parse(strHour); err != nil {
-			return fmt.Errorf("ParseTime(): in parse [hour]/min/sec, err=\n\t%w", err)
-		}
-	}
-	sf.intVal = sf.hour.Get()*3600 + sf.min.Get()*60 + sf.sec.Get()
-	return nil
-}
-
-// Hour -- возвращает хранимые часы
-func (sf *ParseTime) Hour() *parsehour.ParseHour {
-	return sf.hour
-}
-
-// Min -- возвращает хранимые минуты
-func (sf *ParseTime) Min() *parsemin.ParseMin {
-	return sf.min
-}
-
-// Sec -- возвращает хранимые секунды
-func (sf *ParseTime) Sec() *parsesec.ParseSec {
-	return sf.sec
-}
-
-// String -- возвращает хранимое время
-func (sf *ParseTime) String() string {
-	res := sf.hour.String() + ":" + sf.min.String() + ":" + sf.sec.String()
-	return res
-}

pkg/components/product/product.go

@@ -0,0 +1,41 @@
+// package product -- объект продукта для производства
+package product
+
+import (
+	"wartank/pkg/components/parser_time"
+	"wartank/pkg/components/safe_int"
+	"wartank/pkg/components/safe_string"
+	"wartank/pkg/types"
+)
+
+// Продукт -- объект продукта для производства
+type Продукт struct {
+	имя   *safe_string.БезопСтрока // имя продукта
+	кол   *safe_int.БезопЦелое     // Количество продукта
+	время *parser_time.ПарсерВремя // Время для производства продукта
+}
+
+// НовПродукт -- возвращает новый объект продукта
+func НовПродукт() *Продукт {
+	сам := &Продукт{
+		имя:   safe_string.НовБезопСтрока(),
+		кол:   safe_int.НовБезопЦелое(),
+		время: parser_time.НовПарсерВремя(),
+	}
+	return сам
+}
+
+// Имя -- возвращает название продукта
+func (сам *Продукт) Имя() types.ИБезопСтрока {
+	return сам.имя
+}
+
+// Кол -- возвращает количество продукта
+func (сам *Продукт)Кол()types.ИБезопЦелое{
+	return сам.кол
+}
+
+// Время -- возвращает время производства
+func (сам *Продукт)Время()types.ИПарсерВремя{
+	return сам.время
+}

pkg/components/safebool/safebool.go → pkg/components/safe_bool/safe_bool.go

@@ -1,4 +1,4 @@
-package safebool
+package safe_bool
 
 import "sync"
 
@@ -6,33 +6,33 @@ import "sync"
 	Потокобезопасный булевый признак.
 */
 
-// SafeBool -- потокобезопасный булевый признак
-type SafeBool struct {
+// БезопБул -- потокобезопасный булевый признак
+type БезопБул struct {
 	val   bool
 	block sync.RWMutex
 }
 
-// NewSafeBool -- возвращает новый *SafeBool
-func NewSafeBool() *SafeBool {
-	return &SafeBool{}
+// НовБезопБул -- возвращает новый *SafeBool
+func НовБезопБул() *БезопБул {
+	return &БезопБул{}
 }
 
 // Получ -- возвращает хранимое значение булевого признака
-func (sf *SafeBool) Получ() bool {
+func (sf *БезопБул) Получ() bool {
 	sf.block.RLock()
 	defer sf.block.RUnlock()
 	return sf.val
 }
 
 // Уст -- устанавливает хранимое значение булевого признака
-func (sf *SafeBool) Уст() {
+func (sf *БезопБул) Уст() {
 	sf.block.Lock()
 	defer sf.block.Unlock()
 	sf.val = true
 }
 
 // Сброс -- сбарсывает хранимое значение булевого признака
-func (sf *SafeBool) Сброс() {
+func (sf *БезопБул) Сброс() {
 	sf.block.Lock()
 	defer sf.block.Unlock()
 	sf.val = false

pkg/components/safebool/safebool_test.go → pkg/components/safe_bool/safe_bool_test.go

@@ -1,4 +1,4 @@
-package safebool
+package safe_bool
 
 import "testing"
 
@@ -9,7 +9,7 @@ import "testing"
 // Тестер для булевого признака
 type tester struct {
 	t  *testing.T
-	sb *SafeBool
+	sb *БезопБул
 }
 
 func TestSafeBool(t *testing.T) {
@@ -36,7 +36,7 @@ func (sf *tester) set() {
 // Создание признака
 func (sf *tester) create() {
 	sf.t.Logf("=create=\n")
-	sf.sb = NewSafeBool()
+	sf.sb = НовБезопБул()
 	if sf.sb == nil {
 		sf.t.Errorf("create(): safeBool==nil\n")
 	}

pkg/components/safe_int/safe_int.go

@@ -0,0 +1,32 @@
+package safe_int
+
+import "sync"
+
+/*
+	Потокобезопасное целое
+*/
+
+// БезопЦелое -- потокобезопасное целое
+type БезопЦелое struct {
+	знач   int
+	блок sync.RWMutex
+}
+
+// НовБезопЦелое -- возвращает новый *БезопЦелое
+func НовБезопЦелое() *БезопЦелое {
+	return &БезопЦелое{}
+}
+
+// Получ -- возвращает хранимое значение
+func (sf *БезопЦелое) Получ() int {
+	sf.блок.RLock()
+	defer sf.блок.RUnlock()
+	return sf.знач
+}
+
+// Уст -- устанавливает хранимое значение
+func (sf *БезопЦелое) Уст(val int) {
+	sf.блок.Lock()
+	defer sf.блок.Unlock()
+	sf.знач = val
+}

pkg/components/safeint/safeint_test.go → pkg/components/safe_int/safe_int_test.go

@@ -1,4 +1,4 @@
-package safeint
+package safe_int
 
 import (
 	"testing"
@@ -11,7 +11,7 @@ import (
 // Тестер для безопасного целого
 type tester struct {
 	t  *testing.T
-	si *SafeInt
+	si *БезопЦелое
 }
 
 func TestSafeInt(t *testing.T) {
@@ -26,7 +26,7 @@ func TestSafeInt(t *testing.T) {
 func (sf *tester) set() {
 	sf.t.Logf("=set=\n")
 	sf.si.Уст(-8)
-	if val := sf.si.Get(); val != -8 {
+	if val := sf.si.Получ(); val != -8 {
 		sf.t.Errorf("create(): val(%d)!=-8\n", val)
 	}
 }
@@ -34,11 +34,11 @@ func (sf *tester) set() {
 // Создание целого
 func (sf *tester) create() {
 	sf.t.Logf("=create=\n")
-	sf.si = NewSafeInt()
+	sf.si = НовБезопЦелое()
 	if sf.si == nil {
 		sf.t.Errorf("create(): safeInt==nil\n")
 	}
-	if val := sf.si.Get(); val != 0 {
+	if val := sf.si.Получ(); val != 0 {
 		sf.t.Errorf("create(): val(%d)!=0\n", val)
 	}
 }

pkg/components/safe_string/safe_string.go

@@ -0,0 +1,32 @@
+package safe_string
+
+import "sync"
+
+/*
+	Потокобезопасная строка
+*/
+
+// БезопСтрока -- потокобезопасная строка
+type БезопСтрока struct {
+	знач   string
+	блок sync.RWMutex
+}
+
+// НовБезопСтрока -- возвращает новый *SafeString
+func НовБезопСтрока() *БезопСтрока {
+	return &БезопСтрока{}
+}
+
+// Получ -- возвращает хранимое значение
+func (sf *БезопСтрока) Получ() string {
+	sf.блок.RLock()
+	defer sf.блок.RUnlock()
+	return sf.знач
+}
+
+// Уст -- устанавливает хранимое значение
+func (sf *БезопСтрока) Уст(знач string) {
+	sf.блок.Lock()
+	defer sf.блок.Unlock()
+	sf.знач = знач
+}

pkg/components/safestring/safestring_test.go → pkg/components/safe_string/safe_string_test.go

@@ -1,4 +1,4 @@
-package safestring
+package safe_string
 
 import (
 	"testing"
@@ -11,7 +11,7 @@ import (
 // Тестер для безопасной строки
 type tester struct {
 	t  *testing.T
-	si *SafeString
+	si *БезопСтрока
 }
 
 func TestSafeString(t *testing.T) {
@@ -25,8 +25,8 @@ func TestSafeString(t *testing.T) {
 // Установка значения
 func (sf *tester) set() {
 	sf.t.Logf("=set=\n")
-	sf.si.Set("test_str")
-	if val := sf.si.Get(); val != "test_str" {
+	sf.si.Уст("test_str")
+	if val := sf.si.Получ(); val != "test_str" {
 		sf.t.Errorf("create(): val(%s)!='test_str'\n", val)
 	}
 }
@@ -34,11 +34,11 @@ func (sf *tester) set() {
 // Создание целого
 func (sf *tester) create() {
 	sf.t.Logf("=create=\n")
-	sf.si = NewSafeString()
+	sf.si = НовБезопСтрока()
 	if sf.si == nil {
 		sf.t.Errorf("create(): safeString==nil\n")
 	}
-	if val := sf.si.Get(); val != "" {
+	if val := sf.si.Получ(); val != "" {
 		sf.t.Errorf("create(): val(%s)!=``\n", val)
 	}
 }

pkg/components/safeint/safeint.go

@@ -1,32 +0,0 @@
-package safeint
-
-import "sync"
-
-/*
-	Потокобезопасное целое
-*/
-
-// SafeInt -- потокобезопасное целое
-type SafeInt struct {
-	val   int
-	block sync.RWMutex
-}
-
-// NewSafeInt -- возвращает новый *SafeInt
-func NewSafeInt() *SafeInt {
-	return &SafeInt{}
-}
-
-// Get -- возвращает хранимое значение
-func (sf *SafeInt) Get() int {
-	sf.block.RLock()
-	defer sf.block.RUnlock()
-	return sf.val
-}
-
-// Уст -- устанавливает хранимое значение
-func (sf *SafeInt) Уст(val int) {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	sf.val = val
-}

pkg/components/safestring/safestring.go

@@ -1,32 +0,0 @@
-package safestring
-
-import "sync"
-
-/*
-	Потокобезопасная строка
-*/
-
-// SafeString -- потокобезопасная строка
-type SafeString struct {
-	val   string
-	block sync.RWMutex
-}
-
-// NewSafeString -- возвращает новый *SafeString
-func NewSafeString() *SafeString {
-	return &SafeString{}
-}
-
-// Get -- возвращает хранимое значение
-func (sf *SafeString) Get() string {
-	sf.block.RLock()
-	defer sf.block.RUnlock()
-	return sf.val
-}
-
-// Set -- устанавливает хранимое значение
-func (sf *SafeString) Set(strVal string) {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	sf.val = strVal
-}

pkg/components/section/down_time/down_time.go

@@ -9,9 +9,9 @@ import (
 	"sync"
 	"time"
 
-	"wartank/pkg/components/parsetime"
-	"wartank/pkg/components/safebool"
-	"wartank/pkg/components/safeint"
+	"wartank/pkg/components/parser_time"
+	"wartank/pkg/components/safe_bool"
+	"wartank/pkg/components/safe_int"
 	"wartank/pkg/types"
 )
 
@@ -23,11 +23,11 @@ const (
 type ВремОбрат struct {
 	сцена types.ИСцена
 
-	парсер *parsetime.ParseTime // Парсер значения
+	время types.ИПарсерВремя // Парсер значения
 
-	времяЗнач    *safeint.SafeInt   // Фактическое значение счётчика
-	времПорог    *safeint.SafeInt   // Целевое время срабатывания
-	еслиРаботает *safebool.SafeBool // Признак работы
+	времяЗнач    *safe_int.БезопЦелое // Фактическое значение счётчика
+	времПорог    *safe_int.БезопЦелое // Целевое время срабатывания
+	еслиРаботает *safe_bool.БезопБул  // Признак работы
 
 	канТик   chan int // Канал секундных интервалов сна (для отображения)
 	канВызов chan int // Канал для отправки сигналов (для верхнего уровня)
@@ -46,12 +46,12 @@ func НовВремОбрат(сцена types.ИСцена, знач int) *Вр
 	кнт, фнОтмена := context.WithCancel(сцена.Кнт())
 	сам := &ВремОбрат{
 		сцена:        сцена,
-		времяЗнач:    safeint.NewSafeInt(),
+		времяЗнач:    safe_int.НовБезопЦелое(),
 		канТик:       make(chan int, 5),
 		канВызов:     make(chan int, 2),
-		еслиРаботает: safebool.NewSafeBool(),
-		парсер:       parsetime.NewParseTime(),
-		времПорог:    safeint.NewSafeInt(),
+		еслиРаботает: safe_bool.НовБезопБул(),
+		время:        parser_time.НовПарсерВремя(),
+		времПорог:    safe_int.НовБезопЦелое(),
 		кнт:          кнт,
 		фнОтмена:     фнОтмена,
 	}
@@ -94,7 +94,7 @@ func (sf *ВремОбрат) пуск() {
 	for range sf.канТик {
 		time.Sleep(time.Millisecond * 100)
 		timeNow := time.Now().UTC().Unix()
-		if sf.времПорог.Get() > int(timeNow) {
+		if sf.времПорог.Получ() > int(timeNow) {
 			continue
 		}
 		close(sf.канВызов)
@@ -110,7 +110,7 @@ func (sf *ВремОбрат) Стоп() {
 
 // Получ -- возвращает число оставшихся сек
 func (sf *ВремОбрат) Получ() int {
-	return sf.времяЗнач.Get()
+	return sf.времяЗнач.Получ()
 }
 
 // устанавливает число оставшихся сек
@@ -120,10 +120,10 @@ func (sf *ВремОбрат) parse(val string) error {
 	if val == "" {
 		return fmt.Errorf("CountTime.parse(): val is empty")
 	}
-	sf.парсер.Parse(val)
-	_val := sf.парсер.Hour().Get()*3600 + sf.парсер.Min().Get()*60 + sf.парсер.Min().Get()
+	sf.время.Уст(val)
+	_val := sf.время.Hour().Get()*3600 + sf.время.Min().Get()*60 + sf.время.Min().Get()
 	sf.времяЗнач.Уст(_val)
-	_val = int(time.Now().UTC().Unix()) + sf.времяЗнач.Get()
+	_val = int(time.Now().UTC().Unix()) + sf.времяЗнач.Получ()
 	sf.времПорог.Уст(_val)
 	return nil
 }
@@ -138,24 +138,24 @@ func (sf *ВремОбрат) set_val(val int) error {
 	sf.времяЗнач.Уст(val)
 	{ // Обновить локальные счётчики
 		if val < 60 {
-			sf.парсер.Hour().Reset()
-			sf.парсер.Min().Reset()
-			sf.парсер.Sec().Set(val)
+			sf.время.Hour().Reset()
+			sf.время.Min().Reset()
+			sf.время.Sec().Set(val)
 			return nil
 		}
 		if 60 < val && val < 3600 {
-			sf.парсер.Hour().Reset()
+			sf.время.Hour().Reset()
 			iMin := val / 60
-			sf.парсер.Min().Set(iMin)
+			sf.время.Min().Set(iMin)
 			val -= iMin * 60
-			sf.парсер.Sec().Set(val)
+			sf.время.Sec().Set(val)
 			return nil
 		}
-		sf.парсер.Hour().Set(val / 3600)
-		val -= sf.парсер.Hour().Get() * 3600
-		sf.парсер.Min().Set(val / 60)
-		val -= sf.парсер.Min().Get() * 60
-		sf.парсер.Sec().Set(val)
+		sf.время.Hour().Set(val / 3600)
+		val -= sf.время.Hour().Get() * 3600
+		sf.время.Min().Set(val / 60)
+		val -= sf.время.Min().Get() * 60
+		sf.время.Sec().Set(val)
 		// val = int(time.Now().UTC().Unix()) + sf.val.Get()
 	}
 	return nil
@@ -166,9 +166,9 @@ func (sf *ВремОбрат) Стр() string {
 	sf.блок.RLock()
 	defer sf.блок.RUnlock()
 	timeNow := time.Now().UTC().Unix()
-	val := sf.времПорог.Get() - int(timeNow)
+	val := sf.времПорог.Получ() - int(timeNow)
 	go sf.set_val(val)
-	return sf.парсер.String()
+	return sf.время.String()
 }
 
 // КаналСиг -- возвращает канал чтения тиков

pkg/components/section/down_time/down_time_test.go

@@ -3,7 +3,7 @@ package down_time
 import (
 	"testing"
 	"time"
-	"wartank/pkg/components/safebool"
+	"wartank/pkg/components/safe_bool"
 	"wartank/pkg/mock/mock_zone"
 	"wartank/pkg/mock/mockapp"
 	"wartank/pkg/types"
@@ -20,7 +20,7 @@ type tester struct {
 	zone   types.ИСцена
 	ct     *ВремОбрат
 	err    error
-	isCall *safebool.SafeBool // Признак обратного вызова
+	isCall *safe_bool.БезопБул // Признак обратного вызова
 }
 
 // Обратный вызов для счётчика времени
@@ -36,7 +36,7 @@ func (sf *tester) call() {
 func TestCountTime(t *testing.T) {
 	test := &tester{
 		t:      t,
-		isCall: safebool.NewSafeBool(),
+		isCall: safe_bool.НовБезопБул(),
 		app:    mockapp.NewMockApp(),
 	}
 	time.Sleep(time.Millisecond * 100)
@@ -182,14 +182,14 @@ func (sf *tester) setInt() {
 		if sf.err = ct.set_val(8); sf.err != nil {
 			sf.t.Errorf("setInt(): GOOD-1 err=%v", sf.err)
 		}
-		if ct.парсер.Hour().Get() != 0 {
-			sf.t.Errorf("setInt(): GOOD-1 hour(%v)!=0", sf.ct.парсер.Hour().Get())
+		if ct.время.Hour().Get() != 0 {
+			sf.t.Errorf("setInt(): GOOD-1 hour(%v)!=0", sf.ct.время.Hour().Get())
 		}
-		if ct.парсер.Min().Get() != 0 {
-			sf.t.Errorf("setInt(): GOOD-1 min(%v)!=0", sf.ct.парсер.Min().Get())
+		if ct.время.Min().Get() != 0 {
+			sf.t.Errorf("setInt(): GOOD-1 min(%v)!=0", sf.ct.время.Min().Get())
 		}
-		if ct.парсер.Sec().Get() != 8 {
-			sf.t.Errorf("setInt(): GOOD-1 sec(%v)!=8", sf.ct.парсер.Sec().Get())
+		if ct.время.Sec().Get() != 8 {
+			sf.t.Errorf("setInt(): GOOD-1 sec(%v)!=8", sf.ct.время.Sec().Get())
 		}
 		if strVal := ct.Стр(); strVal != "00:00:08" {
 			sf.t.Errorf("setInt(): GOOD-1 strVal(%v)!='00:00:08'", strVal)
@@ -199,14 +199,14 @@ func (sf *tester) setInt() {
 		if sf.err = ct.set_val(121); sf.err != nil {
 			sf.t.Errorf("setInt(): GOOD-2 err=%v", sf.err)
 		}
-		if ct.парсер.Hour().Get() != 0 {
-			sf.t.Errorf("setInt(): GOOD-2 hour(%v)!=0", sf.ct.парсер.Hour().Get())
+		if ct.время.Hour().Get() != 0 {
+			sf.t.Errorf("setInt(): GOOD-2 hour(%v)!=0", sf.ct.время.Hour().Get())
 		}
-		if ct.парсер.Min().Get() != 2 {
-			sf.t.Errorf("setInt(): GOOD-2 min(%v)!=2", sf.ct.парсер.Min().Get())
+		if ct.время.Min().Get() != 2 {
+			sf.t.Errorf("setInt(): GOOD-2 min(%v)!=2", sf.ct.время.Min().Get())
 		}
-		if ct.парсер.Sec().Get() != 1 {
-			sf.t.Errorf("setInt(): GOOD-2 sec(%v)!=1", sf.ct.парсер.Sec().Get())
+		if ct.время.Sec().Get() != 1 {
+			sf.t.Errorf("setInt(): GOOD-2 sec(%v)!=1", sf.ct.время.Sec().Get())
 		}
 		if strVal := ct.Стр(); strVal != "00:02:01" {
 			sf.t.Errorf("setInt(): GOOD-2 strVal(%v)!='00:02:01'", strVal)
@@ -216,14 +216,14 @@ func (sf *tester) setInt() {
 		if sf.err = ct.set_val(7203); sf.err != nil {
 			sf.t.Errorf("setInt(): GOOD-3 err=%v", sf.err)
 		}
-		if ct.парсер.Hour().Get() != 2 {
-			sf.t.Errorf("setInt(): GOOD-3 hour(%v)!=2", sf.ct.парсер.Hour().Get())
+		if ct.время.Hour().Get() != 2 {
+			sf.t.Errorf("setInt(): GOOD-3 hour(%v)!=2", sf.ct.время.Hour().Get())
 		}
-		if ct.парсер.Min().Get() != 0 {
-			sf.t.Errorf("setInt(): GOOD-3 min(%v)!=0", sf.ct.парсер.Min().Get())
+		if ct.время.Min().Get() != 0 {
+			sf.t.Errorf("setInt(): GOOD-3 min(%v)!=0", sf.ct.время.Min().Get())
 		}
-		if ct.парсер.Sec().Get() != 3 {
-			sf.t.Errorf("setInt(): GOOD-3 sec(%v)!=3", sf.ct.парсер.Sec().Get())
+		if ct.время.Sec().Get() != 3 {
+			sf.t.Errorf("setInt(): GOOD-3 sec(%v)!=3", sf.ct.время.Sec().Get())
 		}
 		if strVal := ct.Стр(); strVal != "02:00:03" {
 			sf.t.Errorf("setInt(): GOOD-3 strVal(%v)!='02:00:03'", strVal)

pkg/components/section/section.go

@@ -7,7 +7,7 @@ import (
 	"sync"
 
 	"wartank/pkg/components/lst_string"
-	"wartank/pkg/components/parsetime"
+	"wartank/pkg/components/parser_time"
 	"wartank/pkg/components/section/down_time"
 	"wartank/pkg/components/section/section_mode"
 	"wartank/pkg/components/section/zone"
@@ -68,7 +68,7 @@ func (сам *Секция) SetCountDown(sec int) error {
 
 // ParseCountDown -- устанавливает новое значение обратного счётчика времени (string)
 func (sf *Секция) ParseCountDown(sec string) error {
-	pt := parsetime.NewParseTime()
+	pt := parser_time.НовПарсерВремя()
 	pt.Parse(sec)
 	_sec := pt.Get()
 	sf.countDown = down_time.НовВремОбрат(sf, _sec)

pkg/store/store.go

@@ -7,7 +7,7 @@ import (
 	"github.com/syndtr/goleveldb/leveldb"
 	"github.com/syndtr/goleveldb/leveldb/util"
 
-	"wartank/pkg/components/safebool"
+	"wartank/pkg/components/safe_bool"
 	"wartank/pkg/types"
 )
 
@@ -19,7 +19,7 @@ const (
 type Store struct {
 	app    types.ИСервер
 	db     *leveldb.DB
-	isWork *safebool.SafeBool
+	isWork *safe_bool.БезопБул
 }
 
 // NewStore - -возвращает новый объект хранилища
@@ -29,7 +29,7 @@ func NewStore(app types.ИСервер) (*Store, error) {
 	}
 	sf := &Store{
 		app:    app,
-		isWork: safebool.NewSafeBool(),
+		isWork: safe_bool.НовБезопБул(),
 	}
 	if err := sf.open(); err != nil {
 		return nil, fmt.Errorf("NewStore(): in open store, err=%w", err)

pkg/types/ibot_net.go

@@ -4,7 +4,7 @@ import (
 	"context"
 	"net/http"
 
-	"wartank/pkg/components/safebool"
+	"wartank/pkg/components/safe_bool"
 )
 
 /*
@@ -14,7 +14,7 @@ import (
 // ИБотСеть -- интерфейс к сетевому клиенту
 type ИБотСеть interface {
 	// ЕслиОнлайн -- возвращает признак подключенности к интернету
-	ЕслиОнлайн() *safebool.SafeBool
+	ЕслиОнлайн() *safe_bool.БезопБул
 	// Коннект -- возвращает объект сетевого подключения
 	Коннект() *http.Client
 	// Куки -- возвращает объект кукисов

pkg/types/idiv_war_action.go

@@ -2,7 +2,7 @@ package types
 
 import (
 	"context"
-	"wartank/pkg/components/safebool"
+	"wartank/pkg/components/safe_bool"
 )
 
 /*
@@ -25,7 +25,7 @@ type ИДивизияВойнаДействие interface {
 	// CancelBattle -- вызывает контекст отмены битвы
 	CancelBattle()
 	// ЕслиКонец -- признак окончания битвы дивизий
-	ЕслиКонец() *safebool.SafeBool
+	ЕслиКонец() *safe_bool.БезопБул
 	// ВыстрелБлок -- объект маскировки
-	ВыстрелБлок() *safebool.SafeBool
+	ВыстрелБлок() *safe_bool.БезопБул
 }

pkg/types/imine.go

@@ -15,8 +15,12 @@ type ИШахта interface {
 	Сталь() ИСтатПарам
 	// Свинец -- возвращает объект свинца
 	Свинец() ИСтатПарам
-	// КолвоРаботаСейчас -- количество производимого продукта
-	КолвоРаботаСейчас() ИСтатПарам
+	// ПродуктКолСейчас -- количество производимого продукта
+	ПродуктКолСейчас() int
+	// ПродуктИмяСейчас -- количество производимого продукта сейчас
+	ПродуктИмяСейчас() string
+	// ПродуктВремяСейчас -- сколько времени до окончания продукта ждать
+	ПродуктВремяСейчас() string
 	// Уровень -- возвращает уровень шахты
 	Уровень() ИСтатПарам
 }

pkg/types/iparser_hour.go

@@ -0,0 +1,9 @@
+package types
+
+import "wartank/pkg/alias"
+
+// ИПарсерЧас --парсер часов
+type ИПарсерЧас interface {
+	// Получ -- возвращает числовое значение часа
+	Получ() alias.Час
+}

pkg/types/iparser_simple.go

@@ -0,0 +1,9 @@
+package types
+
+// ИПарсерПростой -- базовый интерфейс парсеру времени
+type ИПарсерПростой interface {
+	// Уст -- устанавливает часы
+	Уст(string) error
+	// String -- возвращает строковое представление
+	String() string
+}

pkg/types/iparser_time.go

@@ -0,0 +1,13 @@
+package types
+
+// ИПарсерВремя -- интерфейс к строковому времени
+type ИПарсерВремя interface {
+	// Уст -- устанавливает строкове время
+	Уст(string) error
+	// String -- возвращает строку времени
+	String() string
+	// ВсегоСек -- возвращает общее число сек
+	ВсегоСек() int
+	// Час -- возвращает часы
+	Час() ИПарсерЧас
+}

pkg/types/isafe_int.go

@@ -0,0 +1,9 @@
+package types
+
+// ИБезопЦелое -- потокобезопасное целое
+type ИБезопЦелое interface {
+	// Получ -- возвращает хранимое значение
+	Получ() int
+	// Уст -- устанавливает хранимое значение
+	Уст(int)
+}

pkg/types/isafe_string.go

@@ -0,0 +1,9 @@
+package types
+
+// ИБезопСтрока -- потокобезопасная строка
+type ИБезопСтрока interface{
+	// Получ -- возвращает хранимое значение
+	Получ()string
+	// Уст -- устанавливает хранимое значение
+	Уст(string)
+}

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

@@ -211,8 +211,6 @@ func (sf *База) проверитьШахту() {
 		return
 	}
 	sf.шахтаСтатаОбновить()
-	sf.шахтаДелать() // Нужно ли производство в шахте
-
 	sf.checkMineTime()
 }
 
@@ -385,31 +383,6 @@ func (sf *База) шахтаСтатаОбновить() {
 	}
 }
 
-// Проверяет на необходимость производства (* здесь этого быть не должно *)
-func (sf *База) шахтаДелать() {
-	var (
-		strOut  string
-		ind     int
-		isFind  bool
-		lstBase = sf.СписПолучить()
-	)
-	for ind, strOut = range lstBase {
-		if strings.Contains(strOut, `<span class="green2">Шахта -`) {
-			isFind = true
-			ind += 12
-			strOut = lstBase[ind]
-			break
-		}
-	}
-	if !isFind {
-		return
-	}
-	if !strings.Contains(strOut, `"><span><span>Производство</span></span></a>`) {
-		return
-	}
-	sf.шахта.КолвоРаботаСейчас().Уст(0)
-}
-
 // Проверяет режимы арсенала
 func (sf *База) проверитьАрсенал() {
 	// countTime := sf.арсенал.ВремяОпрос().Получ()

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

@@ -20,15 +20,17 @@ import (
 // Шахта -- объект шахты на базе
 type Шахта struct {
 	*section.Секция
-	сеть       *minenet.MineNet
-	бот        types.ИБот
-	база       types.ИБаза
-	руда       types.ИСтатПарам
-	железо     types.ИСтатПарам
-	сталь      types.ИСтатПарам
-	свинец     types.ИСтатПарам
-	numProduct types.ИСтатПарам
-	уровень    types.ИСтатПарам
+	сеть         *minenet.MineNet
+	бот          types.ИБот
+	база         types.ИБаза
+	руда         types.ИСтатПарам
+	железо       types.ИСтатПарам
+	сталь        types.ИСтатПарам
+	свинец       types.ИСтатПарам
+	уровень      types.ИСтатПарам
+	продуктИмя   string           // Что сейчас делается
+	продуктКол   types.ИСтатПарам // Сколько делается прямо сейчас
+	продуктВремя string           // Сколько осталось времени прямо сейчас
 }
 
 // НовШахта -- возвращает новый *Mine
@@ -37,23 +39,23 @@ func НовШахта(база types.ИБаза) (*Шахта, error) {
 	if ош != nil {
 		return nil, fmt.Errorf("НовШахта(): in create *Section, err=\n\t%w", ош)
 	}
-	руда, ош := static_param.НовСтатПарам("ruda")
+	руда, ош := static_param.НовСтатПарам("руда")
 	if ош != nil {
 		return nil, fmt.Errorf("НовШахта(): при создании статистики руды, ош=\n\t%w", ош)
 	}
-	железо, ош := static_param.НовСтатПарам("ferrum")
+	железо, ош := static_param.НовСтатПарам("железо")
 	if ош != nil {
 		return nil, fmt.Errorf("НовШахта(): при создании статистики железа, ош=\n\t%w", ош)
 	}
-	сталь, ош := static_param.НовСтатПарам("steel")
+	сталь, ош := static_param.НовСтатПарам("сталь")
 	if ош != nil {
 		return nil, fmt.Errorf("НовШахта(): при создании статистики стали, ош=\n\t%w", ош)
 	}
-	свинец, ош := static_param.НовСтатПарам("plumbum")
+	свинец, ош := static_param.НовСтатПарам("свинец")
 	if ош != nil {
 		return nil, fmt.Errorf("НовШахта(): при создании статистики свинца, ош=\n\t%w", ош)
 	}
-	добычаЧисло, ош := static_param.НовСтатПарам("plumbum")
+	добычаЧисло, ош := static_param.НовСтатПарам("свинец")
 	if ош != nil {
 		return nil, fmt.Errorf("НовШахта(): при создании статистики числа добычи, ош=\n\t%w", ош)
 	}
@@ -69,7 +71,7 @@ func НовШахта(база types.ИБаза) (*Шахта, error) {
 		железо:     железо,
 		сталь:      сталь,
 		свинец:     свинец,
-		numProduct: добычаЧисло,
+		продуктКол: добычаЧисло,
 		уровень:    уровень,
 	}
 	сам.сеть, ош = minenet.NewMineNet(сам)
@@ -99,6 +101,7 @@ func (сам *Шахта) пуск() {
 			сам.уровеньОбновить()
 			сам.Сделать()
 			сам.ускорениеПровер()
+			сам.количествоПолучить()
 			сам.бот.Ангар().РесурсыОбновить()
 			сам.Сделать()
 			time.Sleep(time.Minute * 5)
@@ -106,6 +109,62 @@ func (сам *Шахта) пуск() {
 	}
 }
 
+// Проверяет количество продукта в шахте
+func (сам *Шахта) количествоПолучить() {
+	var (
+		ind    int
+		strOut string
+		isFind bool
+		режим  string
+	)
+	lstMine, err := сам.сеть.Клиент().Get("https://wartank.ru/buildings")
+	if err != nil {
+		log.Printf("Шахта.количествоПолучить(): при обновлении строк шахты, ош=\n\t%v\n", err)
+		return
+	}
+	/*
+		Режим (руда-1):
+		<td class="vam"><div class="nwr pr5 gray1"><img class="rico vm" src="/images/icons/ore.png?2" alt="ore"/>&nbsp;1</div></td>
+
+		Время (+8 строк):
+		<td class="vam"><div class="nwr pr5 gray1"><img class="rico vm" src="/images/icons/ore.png?2" alt="ore"/>&nbsp;1</div></td>
+	*/
+	for ind, strOut = range lstMine {
+		// Руда
+		if strings.Contains(strOut, `src="/images/icons/ore.png?2" alt="ore"`) {
+			// <td class="vam"><div class="nwr pr5 gray1"><img class="rico vm" src="/images/icons/ore.png?2" alt="ore"/>&nbsp;1</div></td>
+			isFind = true
+			режим = "руда"
+			break
+		}
+	}
+	if !isFind {
+		return
+	}
+	switch режим {
+	case "руда":
+		_число := strings.TrimPrefix(strOut, `<td class="vam"><div class="nwr pr5 gray1"><img class="rico vm" src="/images/icons/ore.png?2" alt="ore"/>&nbsp;`)
+		_число = strings.TrimSuffix(_число, `</div></td>`)
+		iNum, err := strconv.Atoi(_число)
+		if err != nil {
+			log.Printf("Шахта.количествоПолучить(): кол-во руды (%v) не число, err=\n\t%v\n", _число, err)
+			return
+		}
+		сам.продуктКол.Уст(iNum)
+		сам.продуктИмя = "руда"
+	default:
+	}
+	// <td><div class="value-block lh1"><span><span>00:00:34</span></span></div></td>
+	strTime := lstMine[ind+3]
+	// <td><div class="value-block lh1"><span><span>00:19:53</span></span></div></td>
+	strTime = strings.TrimPrefix(strTime, `<td><div class="value-block lh1"><span><span>`)
+	strTime = strings.TrimSuffix(strTime, `</span></span></div></td>`)
+	сам.продуктВремя=strTime
+	if err := сам.ParseCountDown(strTime); err != nil {
+		log.Printf("Шахта.количествоПолучить(): при установке времени производства(%v), err=\n\t%v\n", strTime, err)
+	}
+}
+
 // Проверяет на забор из шахты
 func (сам *Шахта) шахтаЗабрать() {
 	var (
@@ -254,11 +313,6 @@ func (сам *Шахта) построить(списСтр []string) {
 
 // Сделать -- вызывается с базы, если она обнаружила, что пора сделать продукцию
 func (сам *Шахта) Сделать() {
-	работа := сам.РежимТекущ().Режим()
-	log.Printf("Шахта.Сделать(): work=%v\n", работа)
-	if работа == "upgrade" {
-		return
-	}
 	if err := сам.сеть.UpdateLst(); err != nil {
 		log.Printf("ERRO Шахта.Сделать(): при обновлении lstMine, err=\n\t%v\n", err)
 		return
@@ -270,7 +324,7 @@ func (сам *Шахта) Сделать() {
 		log.Printf("ERRO Шахта.Сделать(): при выборе продукции, err=\n\t%v\n", err)
 		return
 	}
-	работа = сам.РежимТекущ().Режим()
+	работа := сам.РежимТекущ().Режим()
 	switch работа {
 	case "руда":
 		сам.рудаСделать()
@@ -305,44 +359,56 @@ func (сам *Шахта) Руда() types.ИСтатПарам {
 	return сам.руда
 }
 
-// КолвоРаботаСейчас -- возвращает количество прозводимого продукта
-func (сам *Шахта) КолвоРаботаСейчас() types.ИСтатПарам {
-	return сам.numProduct
+// ПродуктКолСейчас -- возвращает количество прозводимого продукта
+func (сам *Шахта) ПродуктКолСейчас() int {
+	return сам.продуктКол.Получ()
+}
+
+// ПродуктИмяСейчас -- возвращает имя прозводимого продукта
+func (сам *Шахта) ПродуктИмяСейчас() string {
+	return сам.продуктИмя
+}
+
+// ПродуктВремяСейчас -- сколько осталось времени до производства продукта
+func (сам *Шахта) ПродуктВремяСейчас() string {
+	сам.количествоПолучить()
+	return сам.продуктВремя
+	// return сам.Секция.ВремяОпрос().Стр()
 }
 
 // Выбирает продукцию по возможности произвести и её количеству
 func (сам *Шахта) выбратьМеталл() error {
 	var (
-		mapProduct = make(map[string]bool) // Словарь известной продукции
-		lstMine    = сам.СписПолучить()
+		диктПродукция = make(map[string]bool) // Словарь известной продукции
+		lstMine       = сам.СписПолучить()
 	)
 
 	фнВыбратьПродукт := func() { // вычисляет список допустимой продукции
-		mapProduct["ruda"] = true // Руда есть всегда
-		mapProduct["ferrum"] = false
-		mapProduct["steel"] = false
-		mapProduct["plumbum"] = false
+		диктПродукция["руда"] = true // Руда есть всегда
+		диктПродукция["железо"] = false
+		диктПродукция["сталь"] = false
+		диктПродукция["свинец"] = false
 		for _, strProd := range lstMine { // Проверить руду
 			if strings.Contains(strProd, `<span class="green2">Руда</span><br/>`) {
-				mapProduct["ruda"] = true
+				диктПродукция["руда"] = true
 				break
 			}
 		}
 		for _, strProd := range lstMine { // Проверить руду
 			if strings.Contains(strProd, `<span class="green2">Железо</span><br/>`) {
-				mapProduct["ferrum"] = true
+				диктПродукция["железо"] = true
 				break
 			}
 		}
 		for _, strProd := range lstMine { // Проверить сталь
 			if strings.Contains(strProd, `<span class="green2">Сталь</span><br/>`) {
-				mapProduct["steel"] = true
+				диктПродукция["сталь"] = true
 				break
 			}
 		}
 		for _, strProd := range lstMine { // Проверить свинец
 			if strings.Contains(strProd, `<span class="green2">Свинец</span><br/>`) {
-				mapProduct["plumbum"] = true
+				диктПродукция["свинец"] = true
 				break
 			}
 		}
@@ -351,21 +417,21 @@ func (сам *Шахта) выбратьМеталл() error {
 	сам.РежимТекущ().РежимУст("руда")
 	руда := сам.Руда().Получ()
 	железо := сам.Железо().Получ()
-	if mapProduct["ferrum"] {
+	if диктПродукция["железо"] {
 		if руда > железо*2 {
 			сам.РежимТекущ().РежимУст("железо")
 		}
 	}
 
 	сталь := сам.Сталь().Получ()
-	if mapProduct["steel"] {
+	if диктПродукция["сталь"] {
 		if железо > сталь*2 {
 			сам.РежимТекущ().РежимУст("сталь")
 		}
 	}
 
 	свинец := сам.Свинец().Получ()
-	if mapProduct["plumbum"] {
+	if диктПродукция["свинец"] {
 		if сталь > свинец*2 {
 			сам.РежимТекущ().РежимУст("свинец")
 		}
@@ -433,7 +499,7 @@ func (сам *Шахта) рудаСделать() {
 		// log._rintf("ERRO Шахта.сделатьРуду(): кол-во(%v) не число, err=\n\t%v\n", strNum, err)
 		return
 	}
-	сам.КолвоРаботаСейчас().Уст(iNum)
+	сам.продуктКол.Уст(iNum)
 }
 
 // Создаёт железо
@@ -493,7 +559,7 @@ func (сам *Шахта) железоСделать() {
 		// log._rintf("ERRO MineNet.makeFerrum(): кол-во(%v) не число, err=\n\t%v\n", strNum, err)
 		return
 	}
-	сам.КолвоРаботаСейчас().Уст(iNum)
+	сам.продуктКол.Уст(iNum)
 }
 
 // Создаёт сталь
@@ -553,7 +619,7 @@ func (сам *Шахта) стальСделать() {
 		// log._rintf("ERRO MineNet.makeSteel(): кол-во(%v) не число, err=\n\t%v\n", strNum, err)
 		return
 	}
-	сам.КолвоРаботаСейчас().Уст(iNum)
+	сам.продуктКол.Уст(iNum)
 }
 
 // Создаёт свинец
@@ -613,5 +679,5 @@ func (сам *Шахта) свинецСделать() {
 		// log._rintf("ERRO Шахта.сделатьСвинец(): кол-во(%v) не число, err=\n\t%v\n", strNum, err)
 		return
 	}
-	сам.КолвоРаботаСейчас().Уст(iNum)
+	сам.продуктКол.Уст(iNum)
 }

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

@@ -14,7 +14,7 @@ import (
 
 // Damage -- урон танка с памятью
 type Damage struct {
-	val   alias.ADamage
+	val   alias.Урон
 	res   string
 	block sync.RWMutex
 }
@@ -27,7 +27,7 @@ func NewDamage() *Damage {
 }
 
 // Set -- устанавливает урон
-func (sf *Damage) Set(val alias.ADamage) {
+func (sf *Damage) Set(val alias.Урон) {
 	sf.block.Lock()
 	defer sf.block.Unlock()
 	if sf.val == 0 { // Первоначальное присвоение

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

@@ -14,7 +14,7 @@ import (
 
 // ShotTime -- время до выстрела
 type ShotTime struct {
-	val   alias.AMilSec // Время в мсек
+	val   alias.МилСек // Время в мсек
 	block sync.RWMutex
 }
 
@@ -24,7 +24,7 @@ func NewShotTime() *ShotTime {
 }
 
 // Get -- возвращает хранимое время до выстрела
-func (sf *ShotTime) Get() alias.AMilSec {
+func (sf *ShotTime) Get() alias.МилСек {
 	sf.block.RLock()
 	defer sf.block.RUnlock()
 	return sf.val
@@ -65,7 +65,7 @@ func (sf *ShotTime) IsZero() bool {
 }
 
 // Set -- устанавливает значение по требованию
-func (sf *ShotTime) Set(val alias.AMilSec) {
+func (sf *ShotTime) Set(val alias.МилСек) {
 	sf.block.Lock()
 	defer sf.block.Unlock()
 	if val < 0 {

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

@@ -69,15 +69,20 @@ func (sf *Конвой) Слава() types.ИСтатПарам {
 
 // обрабатывает конвой
 func (сам *Конвой) пуск() {
+	фнЦикл := func() {
+		сам.проверитьМиссия6фрагов()
+		сам.проверитьМиссияРазведкаКонвой()
+		сам.проверитьМиссияМастерРазведки()
+		сам.атаковать()
+	}
 	for {
 		select {
 		case <-сам.бот.Кнт().Done():
 			return
 		default:
-			сам.проверитьМиссия6фрагов()
-			сам.проверитьМиссияРазведкаКонвой()
-			сам.проверитьМиссияМастерРазведки()
-			сам.атаковать()
+			фнЦикл()
+			time.Sleep(time.Second * 3)
+			фнЦикл() // Для второго шага
 			time.Sleep(time.Minute * 20)
 		}
 	}
@@ -190,7 +195,6 @@ func (sf *Конвой) обновитьВремя() {
 func (сам *Конвой) найтиВбой() string {
 	var (
 		strOut    = ""
-		lstConvoy = сам.СписПолучить()
 		isFind    bool
 	)
 	lstConvoy, err := сам.net.Клиент().Get("https://wartank.ru/convoy")
@@ -202,12 +206,12 @@ func (сам *Конвой) найтиВбой() string {
 		log.Printf("")
 	}
 	for _, strOut = range lstConvoy {
-		если1 := strings.Contains(strOut, `<span>Начать разведку</span>`)
+		// <div class="bot"><a class="simple-but border" w:id="findEnemy" href="convoy?50-1.ILinkListener-root-findEnemy"><span><span>Начать разведку</span></span></a></div>
+		если1 := strings.Contains(strOut, `.ILinkListener-root-findEnemy"`)
 		if если1 {
-			lstLink := strings.Split(strOut, `<div class="bot"><a class="simple-but border" w:id="findEnemy" href="`)
-			strOut = lstLink[1]
-			lstLink = strings.Split(strOut, `"><span><span>Начать разведку</span></span></a></div>`)
-			strOut = "https://wartank.ru/" + lstLink[0]
+			_ссылка := strings.TrimPrefix(strOut, `<div class="bot"><a class="simple-but border" w:id="findEnemy" href="`)
+			_ссылка = strings.TrimSuffix(_ссылка, `"><span><span>Начать разведку</span></span></a></div>`)
+			strOut = "https://wartank.ru/" + _ссылка
 			isFind = true
 			break
 		}
@@ -262,7 +266,7 @@ func (сам *Конвой) атакаНачать() {
 	}
 	strLink := strOut
 	// Можно начать разведку
-	lstConvoy, err := сам.net.Get(strLink)
+	lstConvoy, err := сам.net.Клиент().Get(strLink)
 	if err != nil {
 		log.Printf("ERRO Конвой.атакаНачать(): при выполнении GET-команды 'В атаку!', err=\n\t%v\n", err)
 		return
@@ -283,53 +287,45 @@ func (сам *Конвой) атакаНачать() {
 		// log._rintf("ERRO Конвой.атакаНачать(): при обновлении lstConvoy, err=\n\t%v\n", err)
 		return
 	}
-	for сам.атакаИскать() {
-	}
+	сам.начатьРазведку()
 	if err := сам.SetCountDown(1); err != nil {
 		panic(fmt.Errorf("Конвой.атакаНачать(): при установке CountDown, err=\n\t%w", err))
 	}
 }
 
 // Выполняет атаку на конвой
-func (sf *Конвой) атакаИскать() (isNext bool) {
+func (sf *Конвой) начатьРазведку() {
 	// Вырезать ссылку на атаку
 	strOut := ""
+	isFind:=false
 	lstConvoy := sf.СписПолучить()
-	// <a href="convoy?13-2.ILinkListener-root-fightView-attackRegular" class="simple-but gray"><span><span>ОБЫЧНЫЕ</span></span></a>
-	for _, strAttack := range lstConvoy {
-		if strings.Contains(strAttack, `>ОБЫЧНЫЕ<`) {
-			strOut = strAttack
+	// <div class="bot"><a class="simple-but border" w:id="findEnemy" href="convoy?50-1.ILinkListener-root-findEnemy"><span><span>Начать разведку</span></span></a></div>
+	for _, strOut = range lstConvoy {
+		if strings.Contains(strOut, `.ILinkListener-root-findEnemy`) {
+			isFind=true
 			break
 		}
-		// Полная маскировка через 39:53
-		if strings.Contains(strAttack, `Полная маскировка через `) {
-			return false
-		}
 	}
-	if strOut == "" { // Нечего атаковать
-		return false
+	if !isFind { // Нечего атаковать
+		return
 	}
 	// Атакуем конвой
-	lstLink := strings.Split(strOut, `<a href="`)
-	if len(lstLink) != 2 {
-		return false
-	}
-	strLink := lstLink[1]
-	lstLink = strings.Split(strLink, `" class="simple-but gray"><span><span>ОБЫЧНЫЕ</span></span></a>`)
-	strLink = "https://wartank.ru/" + lstLink[0]
+	_link := strings.TrimPrefix(strOut, `<div class="bot"><a class="simple-but border" w:id="findEnemy" href="`)
+	_link = strings.TrimSuffix(_link, `"><span><span>Начать разведку</span></span></a></div>`)
+	// https://wartank.ru/convoy?52-1.ILinkListener-root-findEnemy
+	link:= "https://wartank.ru/" + _link
 	{ // Выполнить атаку
 		var err error
-		lstConvoy, err = sf.net.Get(strLink)
+		lstConvoy, err = sf.net.Клиент().Get(link)
 		if err != nil {
-			logrus.WithError(err).Error("ConvoyNet.attack(): in get page find attack")
-			return false
+			log.Printf("Конвой.attack(): in get page find attack, err=\n\t%v\n",err)
+			return
 		}
 		if err = sf.СтрОбновить(lstConvoy); err != nil {
-			logrus.WithError(err).Error("Конвой.attack(): при обновлении lstConvoy")
-			return false
+			log.Printf("Конвой.attack(): при обновлении lstConvoy, err=\n\t%v\n",err)
+			return
 		}
 	}
-	return true
 }
 
 // Забирает награду в конвое "Активируй боевую силу"

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

@@ -6,7 +6,7 @@ import (
 	"strings"
 	"time"
 
-	"wartank/pkg/components/safebool"
+	"wartank/pkg/components/safe_bool"
 	"wartank/pkg/components/section"
 	"wartank/pkg/components/sectionnet"
 	"wartank/pkg/types"
@@ -31,9 +31,9 @@ type DivWarOn struct {
 	health    *health.Health // Текущее здоровье танка
 	manevr    *manevr.Manevr // Возможность маневрирования
 	login     string
-	isMasking *safebool.SafeBool // Признак необходимости маскирования (запрет стрельбы, когда слабое здоровье)
-	chTick    chan int           // Ежесекудная проверка на окончание сражения
-	isEnd     *safebool.SafeBool
+	isMasking *safe_bool.БезопБул // Признак необходимости маскирования (запрет стрельбы, когда слабое здоровье)
+	chTick    chan int            // Ежесекудная проверка на окончание сражения
+	isEnd     *safe_bool.БезопБул
 }
 
 // NewDivWarOn -- возвращает новый *DivWarOn
@@ -47,8 +47,8 @@ func NewDivWarOn(bot types.ИБот) (*DivWarOn, error) {
 		ctxDivWar:      ctxDivWar,
 		fnCancelDivWar: fnCancelDivWar,
 		login:          bot.Имя(),
-		isMasking:      safebool.NewSafeBool(),
-		isEnd:          safebool.NewSafeBool(),
+		isMasking:      safe_bool.НовБезопБул(),
+		isEnd:          safe_bool.НовБезопБул(),
 	}
 	var err error
 	{ // ISection (ожидание)
@@ -156,7 +156,7 @@ func (sf *DivWarOn) checkEnd() bool {
 }
 
 // ЕслиКонец -- возвращает признак окончания сражения (интерфейс)
-func (sf *DivWarOn) ЕслиКонец() *safebool.SafeBool {
+func (sf *DivWarOn) ЕслиКонец() *safe_bool.БезопБул {
 	return sf.isEnd
 }
 
@@ -170,7 +170,7 @@ func (sf *DivWarOn) Манёвр() {
 }
 
 // ВыстрелБлок -- признак запрета стрельбы при слабом здоровье
-func (sf *DivWarOn) ВыстрелБлок() *safebool.SafeBool {
+func (sf *DivWarOn) ВыстрелБлок() *safe_bool.БезопБул {
 	return sf.isMasking
 }
 

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

@@ -13,7 +13,7 @@ import (
 	"wartank/server/serv_bots/warbot/angar/division/divwar/divwaron/health/repairtime"
 
 	// "wartank/internal/components/sound"
-	"wartank/pkg/components/safebool"
+	"wartank/pkg/components/safe_bool"
 	"wartank/pkg/types"
 )
 
@@ -27,9 +27,9 @@ type Health struct {
 	fnCancel                    func()
 	temp                        *healthtime.HealthTime // Изменяемое здоровье танка
 	full                        *healthtime.HealthTime // Полное здоровье танка
-	isRepair                    *safebool.SafeBool     // Необходимость восстановления
+	isRepair                    *safe_bool.БезопБул    // Необходимость восстановления
 	repairTime                  *repairtime.RepairTime // Время до восстановления
-	isEnd                       *safebool.SafeBool     // Ссылка на признак конца сражения
+	isEnd                       *safe_bool.БезопБул    // Ссылка на признак конца сражения
 	login                       string                 // Для поиска контрольных строк
 	chTick                      chan int               // Канал для ровной отправки тиков
 	deltaOld                    int                    // Старая дельта потери здоровья
@@ -38,7 +38,7 @@ type Health struct {
 }
 
 // NewHealth -- возвращает новый *Health
-func NewHealth(divwar types.ИДивизияВойнаДействие, isEnd *safebool.SafeBool, login string) (*Health, error) {
+func NewHealth(divwar types.ИДивизияВойнаДействие, isEnd *safe_bool.БезопБул, login string) (*Health, error) {
 	{ // Предусловия
 		if divwar == nil {
 			return nil, fmt.Errorf("NewHealth(): battle is nil")
@@ -56,7 +56,7 @@ func NewHealth(divwar types.ИДивизияВойнаДействие, isEnd *s
 		ctxBattle:  divwar.Ctx(),
 		temp:       healthtime.NewHealthTime(),
 		full:       healthtime.NewHealthTime(),
-		isRepair:   safebool.NewSafeBool(),
+		isRepair:   safe_bool.НовБезопБул(),
 		repairTime: repairtime.NewRepairTime(),
 		isEnd:      divwar.ЕслиКонец(),
 		login:      login,

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

@@ -14,7 +14,7 @@ import (
 	"wartank/server/serv_bots/warbot/angar/division/divwar/divwaron/manevr/ismanevr"
 
 	// "wartank/internal/components/sound"
-	"wartank/pkg/components/safebool"
+	"wartank/pkg/components/safe_bool"
 	"wartank/pkg/types"
 )
 
@@ -25,7 +25,7 @@ import (
 // Manevr -- маневрирует после выстрела
 type Manevr struct {
 	types.ИДивизияВойнаДействие // FIXME:
-	isEnd                       *safebool.SafeBool
+	isEnd                       *safe_bool.БезопБул
 	ctxEnd                      context.Context
 	isManevr                    *ismanevr.IsManevr     // Возможность выполнить манёвр
 	manevrTime                  *repairtime.RepairTime // Время до востановления манёвра
@@ -33,7 +33,7 @@ type Manevr struct {
 }
 
 // NewManevr -- возвращает новый *Manevr
-func NewManevr(divwar types.ИДивизияВойнаДействие, isDivWar *safebool.SafeBool) (*Manevr, error) {
+func NewManevr(divwar types.ИДивизияВойнаДействие, isDivWar *safe_bool.БезопБул) (*Manevr, error) {
 	{ // Предусловия
 		if divwar == nil {
 			return nil, fmt.Errorf("NewManevr(): battle is nil")

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

@@ -14,7 +14,7 @@ import (
 
 // Damage -- урон танка с памятью
 type Damage struct {
-	val   alias.ADamage
+	val   alias.Урон
 	res   string
 	block sync.RWMutex
 }
@@ -27,7 +27,7 @@ func NewDamage() *Damage {
 }
 
 // Set -- устанавливает урон
-func (sf *Damage) Set(val alias.ADamage) {
+func (sf *Damage) Set(val alias.Урон) {
 	sf.block.Lock()
 	defer sf.block.Unlock()
 	if sf.val == 0 { // Первоначальное присвоение

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

@@ -14,7 +14,7 @@ import (
 
 	// "wartank/internal/components/sound"
 	"wartank/pkg/alias"
-	"wartank/pkg/components/safebool"
+	"wartank/pkg/components/safe_bool"
 	"wartank/pkg/types"
 )
 
@@ -29,14 +29,14 @@ import (
 
 // Shot -- объект выстрела
 type Shot struct {
-	types.ИДивизияВойнаДействие                    // FIXME:
-	recharge                    *shottime.ShotTime // Сколько времени нужно для полной перезарядки
-	damage                      *damage.Damage     // Урон от выстрела с памятью
-	damageSum                   alias.ADamage      // Суммарный урон
-	isEnd                       *safebool.SafeBool // Признак конца сражения
-	login                       string             // Логин для поиска контрольных строк
-	chTick                      chan int           // Тик для выстрела
-	ctxEnd                      context.Context    // Признак окончания сражения
+	types.ИДивизияВойнаДействие                     // FIXME:
+	recharge                    *shottime.ShotTime  // Сколько времени нужно для полной перезарядки
+	damage                      *damage.Damage      // Урон от выстрела с памятью
+	damageSum                   alias.Урон          // Суммарный урон
+	isEnd                       *safe_bool.БезопБул // Признак конца сражения
+	login                       string              // Логин для поиска контрольных строк
+	chTick                      chan int            // Тик для выстрела
+	ctxEnd                      context.Context     // Признак окончания сражения
 }
 
 // NewShot -- возвращает новый *Shot
@@ -206,21 +206,21 @@ func (sf *Shot) findDamage() {
 		// log._rintf("WARN Shot.findDamage(): ошибка в значении урона(%v)\n", iDamage)
 		iDamage = 0
 	}
-	sf.damageSum += alias.ADamage(iDamage)
+	sf.damageSum += alias.Урон(iDamage)
 	// log._rintf("INFO Shot.Damage(): damageSum=%v\n", sf.damageSum)
 	if iDamage < 70 {
-		sf.damage.Set(alias.ADamage(iDamage))
+		sf.damage.Set(alias.Урон(iDamage))
 		sf.recharge.Inc210()
 	}
 	// log._rintf("INFO Shot.findDamage(): выстрел=+%v, урон=%v", iDamage, sf.damageSum)
 	if iDamage == 0 {
 		return
 	}
-	sf.setDamage(alias.ADamage(iDamage))
+	sf.setDamage(alias.Урон(iDamage))
 }
 
 // setDamage -- обновляет время перезарядки в зависимости от произведённого урона
-func (sf *Shot) setDamage(val alias.ADamage) {
+func (sf *Shot) setDamage(val alias.Урон) {
 	sf.damage.Set(val)
 	switch sf.damage.Result() {
 	case "none":
@@ -233,6 +233,6 @@ func (sf *Shot) setDamage(val alias.ADamage) {
 }
 
 // IsEnd -- возвращает объект разрешения стрельбы
-func (sf *Shot) IsEnd() *safebool.SafeBool {
+func (sf *Shot) IsEnd() *safe_bool.БезопБул {
 	return sf.isEnd
 }

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

@@ -14,7 +14,7 @@ import (
 
 // ShotTime -- время до выстрела
 type ShotTime struct {
-	val   alias.AMilSec // Время в мсек
+	val   alias.МилСек // Время в мсек
 	block sync.RWMutex
 }
 
@@ -24,7 +24,7 @@ func NewShotTime() *ShotTime {
 }
 
 // Get -- возвращает хранимое время до выстрела
-func (sf *ShotTime) Get() alias.AMilSec {
+func (sf *ShotTime) Get() alias.МилСек {
 	sf.block.RLock()
 	defer sf.block.RUnlock()
 	return sf.val
@@ -65,7 +65,7 @@ func (sf *ShotTime) IsZero() bool {
 }
 
 // Set -- устанавливает значение по требованию
-func (sf *ShotTime) Set(val alias.AMilSec) {
+func (sf *ShotTime) Set(val alias.МилСек) {
 	sf.block.Lock()
 	defer sf.block.Unlock()
 	if val < 0 {

server/serv_bots/warbot/warbot.go

@@ -8,7 +8,7 @@ import (
 	"strings"
 	"time"
 
-	"wartank/pkg/components/safebool"
+	"wartank/pkg/components/safe_bool"
 	"wartank/pkg/types"
 	"wartank/server/serv_bots/warbot/angar"
 	"wartank/server/serv_bots/warbot/tank"
@@ -24,8 +24,8 @@ type ВарБот struct {
 	errFinal       error // Финальная ошибка работы, если была
 	ангар          types.ИАнгар
 	сеть           types.ИБотСеть
-	еслиРаботает   *safebool.SafeBool
-	еслиАвтозапуск *safebool.SafeBool
+	еслиРаботает   *safe_bool.БезопБул
+	еслиАвтозапуск *safe_bool.БезопБул
 	конфиг         *warbot_config.ВарБотКонфиг // Конфиг бота для хранения в базе
 	кнт            context.Context             // Контекст бота
 	фтОтмена       func()                      // Функция отменя контекста бота
@@ -121,8 +121,8 @@ func создатьЯдроВарБот(серв types.ИСервер, конф
 		сервер:         серв,
 		store:          серв.Store(),
 		танк:           танк,
-		еслиРаботает:   safebool.NewSafeBool(),
-		еслиАвтозапуск: safebool.NewSafeBool(),
+		еслиРаботает:   safe_bool.НовБезопБул(),
+		еслиАвтозапуск: safe_bool.НовБезопБул(),
 		конфиг:         конфиг,
 		кнт:            ctx,
 		фтОтмена:       fnCancel,

server/serv_bots/warbot/warbot_net/warbot_net.go

@@ -6,7 +6,7 @@ import (
 	"log"
 	"net/http"
 
-	"wartank/pkg/components/safebool"
+	"wartank/pkg/components/safe_bool"
 	"wartank/pkg/components/sectionnet/netclient"
 	"wartank/pkg/types"
 	"wartank/server/serv_bots/warbot/warbot_net/bot_net_conn"
@@ -22,7 +22,7 @@ type ВарБотСеть struct {
 	бот        types.ИБот
 	сокет      *bot_net_conn.БотСетьСокет
 	логин      bot_net_login.БотСетьЛогин
-	еслиОнлайн *safebool.SafeBool
+	еслиОнлайн *safe_bool.БезопБул
 	сеть       *netclient.NetClient
 	ctx        context.Context
 	фнОтмена   func()
@@ -38,7 +38,7 @@ func НовВарБотСеть(бот types.ИБот) (*ВарБотСеть, e
 	сам := &ВарБотСеть{
 		бот:        бот,
 		сокет:      bot_net_conn.НовБотСетьСокет(),
-		еслиОнлайн: safebool.NewSafeBool(),
+		еслиОнлайн: safe_bool.НовБезопБул(),
 		ctx:        ctx,
 		фнОтмена:   фнОтмена,
 	}
@@ -71,7 +71,7 @@ func (сам *ВарБотСеть) Отмена() {
 }
 
 // ЕслиОнлайн -- возвращает признак нахождения в онлайне
-func (сам *ВарБотСеть) ЕслиОнлайн() *safebool.SafeBool {
+func (сам *ВарБотСеть) ЕслиОнлайн() *safe_bool.БезопБул {
 	return сам.еслиОнлайн
 }
 

server/serv_web/serv_web.go

@@ -175,6 +175,10 @@ func (сам *СервВеб) постБотСтат(кнт *fiber.Ctx) error {
 	диктБот["прочность"] = fmt.Sprintf("%v", бот.Танк().ТанкСтат().Прочность().Получ())
 	диктБот["мощь"] = fmt.Sprintf("%v", бот.Танк().ТанкСтат().Мощь().Получ())
 	диктБот["шахта_уровень"] = fmt.Sprintf("%v", бот.Ангар().База().Шахта().Уровень().Получ())
+	диктБот["шахта_режим"] = fmt.Sprintf("%v", бот.Ангар().База().Шахта().РежимТекущ().Получ())
+	диктБот["шахта_сделать_кол"] = fmt.Sprintf("%v", бот.Ангар().База().Шахта().ПродуктКолСейчас())
+	диктБот["шахта_сделать_назв"] = бот.Ангар().База().Шахта().ПродуктИмяСейчас()
+	диктБот["шахта_сделать_время"] = бот.Ангар().База().Шахта().ПродуктВремяСейчас()
 	return кнт.JSON(диктБот)
 }