d04 Массовые исправления по коду времени

pkg/alias/alias.go

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

pkg/alias/msec.go

@@ -0,0 +1,9 @@
+package alias
+
+// МилСек -- время в миллисекундах
+type МилСек uint
+
+// Сек -- возвращает полное число секунд
+func (сам МилСек) Сек() Сек {
+	return Сек(сам / 1_000)
+}

pkg/components/parser_time/parse_hour/parse_hour.go

@@ -25,6 +25,11 @@ func НовПарсерЧас() *ПарсерЧас {
 	return сам
 }
 
+// ПолучМилСек -- возвращает общее число милСек
+func (сам *ПарсерЧас) ПолучМилСек() alias.МилСек {
+	return alias.МилСек(сам.знач * 3_600 * 1_000)
+}
+
 // Получ -- возвращает хранимое значение
 func (сам *ПарсерЧас) Получ() alias.Час {
 	сам.блок.RLock()
@@ -50,14 +55,14 @@ func (сам *ПарсерЧас) Сброс() {
 // Уст -- устанавливает значение часов
 //
 //	Значение часов может быть больше 24
-func (sf *ПарсерЧас) Уст(часы string) error {
+func (sf *ПарсерЧас) Уст(часы alias.Время) error {
 	sf.блок.Lock()
 	defer sf.блок.Unlock()
-	цЧасы, err := strconv.Atoi(часы)
+	цЧасы, err := strconv.Atoi(string(часы))
 	if err != nil {
 		return fmt.Errorf("ПарсерЧас.Уст(): часы(%q) не число, err=\n\t%w", часы, err)
 	}
-	if цЧасы<0{
+	if цЧасы < 0 {
 		return fmt.Errorf("ПарсерЧас.Уст(): часы(%q) меньше нуля, err=\n\t%w", часы, err)
 	}
 	if err := sf.уст(alias.Час(цЧасы)); err != nil {
@@ -66,12 +71,12 @@ func (sf *ПарсерЧас) Уст(часы string) error {
 	return nil
 }
 
-// УстЦел -- устанавливает числовое значение часов
-func (sf *ПарсерЧас) УстЦел(часы alias.Час) error {
+// УстЧас -- устанавливает числовое значение часов
+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 fmt.Errorf("ПарсерЧас.УстЧас(): in internal set hour(%v), err=\n\t%w", часы, err)
 	}
 	return nil
 }

pkg/components/parser_time/parse_min/parse_min.go

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

pkg/components/parser_time/parsemin/parsemin_test.go → pkg/components/parser_time/parse_min/parse_min_test.go

@@ -1,4 +1,4 @@
-package parsemin
+package parse_min
 
 import (
 	"testing"
@@ -11,7 +11,7 @@ import (
 // Тестер для проверки парсера времени
 type tester struct {
 	t  *testing.T
-	ph *ParseMin
+	ph *ПарсерМинут
 }
 
 func TestParseMin(t *testing.T) {
@@ -34,7 +34,7 @@ func (sf *tester) set() {
 // Кривое число минут
 func (sf *tester) setBad1() {
 	sf.t.Logf("=setBad1=\n")
-	if err := sf.ph.Set(60); err == nil {
+	if err := sf.ph.УстМин(60); err == nil {
 		sf.t.Errorf("setBad1(): err==nil\n")
 	}
 	if strHour := sf.ph.String(); strHour != "08" {
@@ -44,7 +44,7 @@ func (sf *tester) setBad1() {
 
 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)
 	}
 	if strHour := sf.ph.String(); strHour != "08" {
@@ -55,7 +55,7 @@ func (sf *tester) setGood1() {
 // Сброс часов в ноль
 func (sf *tester) reset() {
 	sf.t.Logf("=reset=\n")
-	sf.ph.Reset()
+	sf.ph.Сброс()
 	if strHour := sf.ph.String(); strHour != "00" {
 		sf.t.Errorf("reset(): strHour(%q)!='00'\n", strHour)
 	}
@@ -72,7 +72,7 @@ func (sf *tester) parse() {
 // Установка правильных минут
 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" {
@@ -83,7 +83,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")
 	}
 }
@@ -91,7 +91,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")
 	}
 }
@@ -99,14 +99,14 @@ func (sf *tester) parseBad1() {
 // Создание парсера минут
 func (sf *tester) create() {
 	sf.t.Logf("=create=\n")
-	sf.ph = NewParseMin()
+	sf.ph = НовПарсерМинут()
 	if sf.ph == nil {
 		sf.t.Errorf("create(): parseHour==nil\n")
 	}
-	if hour := sf.ph.Get(); hour != 0 {
-		sf.t.Errorf("create(): hour(%v)!=0\n", hour)
+	if мин := sf.ph.Получ(); мин != 0 {
+		sf.t.Errorf("create(): мин(%v)!=0\n", мин)
 	}
-	if strHour := sf.ph.String(); strHour != "00" {
-		sf.t.Errorf("create(): strHour(%q)!='00'\n", strHour)
+	if стрМин := sf.ph.String(); стрМин != "00" {
+		sf.t.Errorf("create(): стрМин(%q)!='00'\n", стрМин)
 	}
 }

pkg/components/parser_time/parse_sec/parse_sec.go

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

pkg/components/parser_time/parsesec/parsesec_test.go → pkg/components/parser_time/parse_sec/parse_sec_test.go

@@ -1,4 +1,4 @@
-package parsesec
+package parse_sec
 
 import (
 	"testing"
@@ -11,7 +11,7 @@ import (
 // Тестер для проверки парсера времени
 type tester struct {
 	t  *testing.T
-	ph *ParseSec
+	ph *ПарсерСекунд
 }
 
 func TestParsesec(t *testing.T) {
@@ -27,13 +27,12 @@ func TestParsesec(t *testing.T) {
 // Целочисленная установка секунд
 func (sf *tester) set() {
 	sf.t.Logf("=set=\n")
-	sf.setBad1()
 	sf.setGood1()
 }
 
 func (sf *tester) setGood1() {
 	sf.t.Logf("=setGood1=\n")
-	if err := sf.ph.Set(26); err != nil {
+	if err := sf.ph.УстСек(26); err != nil {
 		sf.t.Errorf("setGood1(): err=\n\t%v\n", err)
 	}
 	if strHour := sf.ph.String(); strHour != "26" {
@@ -41,21 +40,10 @@ func (sf *tester) setGood1() {
 	}
 }
 
-// Отрицательные секунды
-func (sf *tester) setBad1() {
-	sf.t.Logf("=setBad1=\n")
-	if err := sf.ph.Set(-1); err == nil {
-		sf.t.Errorf("setBad1(): err==nil\n")
-	}
-	if strHour := sf.ph.String(); strHour != "59" {
-		sf.t.Errorf("setBad1(): strHour(%q)!='59'\n", strHour)
-	}
-}
-
 // Сброс секунд в ноль
 func (sf *tester) reset() {
 	sf.t.Logf("=reset=\n")
-	sf.ph.Reset()
+	sf.ph.Сброс()
 	if strSec := sf.ph.String(); strSec != "00" {
 		sf.t.Errorf("setGood2(): strSec(%q)!='00'\n", strSec)
 	}
@@ -79,7 +67,7 @@ func (sf *tester) parseGood2() {
 			sf.t.Errorf("parseGood2(): panic=\n\t%v\n", _panic)
 		}
 	}()
-	sf.ph.Parse("59")
+	sf.ph.Уст("59")
 	if strHour := sf.ph.String(); strHour != "59" {
 		sf.t.Errorf("parseGood2(): strHour(%q)!='867'\n", strHour)
 	}
@@ -93,7 +81,7 @@ func (sf *tester) parseGood1() {
 			sf.t.Errorf("parseGood1(): panic=\n\t%v\n", _panic)
 		}
 	}()
-	sf.ph.Parse("8")
+	sf.ph.Уст("8")
 	if strHour := sf.ph.String(); strHour != "08" {
 		sf.t.Errorf("parseGood1(): strHour(%q)!='08'\n", strHour)
 	}
@@ -102,7 +90,7 @@ func (sf *tester) parseGood1() {
 // Установка больших часов
 func (sf *tester) parseBad3() {
 	sf.t.Logf("=parseBad3=\n")
-	if err := sf.ph.Parse("61"); err == nil {
+	if err := sf.ph.Уст("61"); err == nil {
 		sf.t.Errorf("parseBad3(): err==nil\n")
 	}
 }
@@ -110,7 +98,7 @@ func (sf *tester) parseBad3() {
 // Установка отрицательных часов
 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")
 	}
 }
@@ -118,7 +106,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")
 	}
 }
@@ -126,11 +114,11 @@ func (sf *tester) parseBad1() {
 // Создание парсера часов
 func (sf *tester) create() {
 	sf.t.Logf("=create=\n")
-	sf.ph = NewParseSec()
+	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/parsemin/parsemin.go

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

pkg/components/parser_time/parser_time.go

@@ -5,9 +5,10 @@ import (
 	"strings"
 	"sync"
 
+	"wartank/pkg/alias"
 	"wartank/pkg/components/parser_time/parse_hour"
-	"wartank/pkg/components/parser_time/parsemin"
-	"wartank/pkg/components/parser_time/parsesec"
+	"wartank/pkg/components/parser_time/parse_min"
+	"wartank/pkg/components/parser_time/parse_sec"
 	"wartank/pkg/types"
 )
 
@@ -17,89 +18,117 @@ import (
 
 // ПарсерВремя -- потокобезопасный ковырятор строки времени
 type ПарсерВремя struct {
-	всегоСек int                // Числовое значение хранимого времени
-	час      types.ИПарсерЧас   // Часы метки времени
-	мин      *parsemin.ParseMin // Минуты метки времени
-	сек      *parsesec.ParseSec // Секунды метки времени
+	всегоМилСек alias.МилСек     // Числовое значение хранимого времени
+	час         types.ИПарсерЧас // Часы метки времени
+	мин         types.ИПарсерМин // Минуты метки времени
+	сек         types.ИПарсерСек // Секунды метки времени
 
-	block sync.RWMutex
+	блок sync.RWMutex
 }
 
 // НовПарсерВремя -- возвращает новый *ParseTime
 func НовПарсерВремя() *ПарсерВремя {
 	сам := &ПарсерВремя{
 		час: parse_hour.НовПарсерЧас(),
-		мин: parsemin.NewParseMin(),
-		сек: parsesec.NewParseSec(),
+		мин: parse_min.НовПарсерМинут(),
+		сек: parse_sec.НовПарсерСекунд(),
 	}
 	_ = types.ИПарсерВремя(сам)
 	return сам
 }
 
-// ВсегоСек -- возвращает общее число секунд
-func (sf *ПарсерВремя) ВсегоСек() int {
-	sf.block.RLock()
-	defer sf.block.RUnlock()
-	return sf.всегоСек
+// Сброс -- сбрасывает значение интервала времени по требованию
+func (сам *ПарсерВремя) Сброс() {
+	сам.час.Сброс()
+	сам.мин.Сброс()
+	сам.сек.Сброс()
+}
+
+// ПолучМилСек -- возвращает общее число секунд
+func (сам *ПарсерВремя) ПолучМилСек() alias.МилСек {
+	сам.блок.RLock()
+	defer сам.блок.RUnlock()
+	return сам.всегоМилСек
 }
 
 // Уст -- разбирает строковое представление на части
-func (sf *ПарсерВремя) Уст(strTime string) error {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	if strTime == "" {
+func (сам *ПарсерВремя) Уст(стрВремя alias.Время) error {
+	сам.блок.Lock()
+	defer сам.блок.Unlock()
+	if стрВремя == "" {
 		return fmt.Errorf("CountTime.Set(): val is empty")
 	}
+	сам.Сброс()
+	списВремя := strings.Split(string(стрВремя), ":")
+	фнСекУст := func(стрВремя alias.Время) error {
+		if ош := сам.сек.Уст(стрВремя); ош != nil {
+			return fmt.Errorf("ПарсерВремя.Уст().фнСекУст(): при установке секунд, ош=\n\t%w", ош)
+		}
+		return nil
+	}
+	фнМинУст := func() error {
+		стрСек := alias.Время(списВремя[1])
+		if ош := фнСекУст(стрСек); ош != nil {
+			return fmt.Errorf("ПарсерВремя.Уст().фнМинУст(): при установке секунд, ош=\n\t%w", ош)
+		}
+		стрМин := alias.Время(списВремя[0])
+		if ош := сам.мин.Уст(стрМин); ош != nil {
+			return fmt.Errorf("ПарсерВремя.Уст().фнМинУст(): при установке минут, ош=\n\t%w", ош)
+		}
+		return nil
+	}
+	фнЧасУст := func() error {
+		стрСек := alias.Время(списВремя[2])
+		if ош := фнСекУст(стрСек); ош != nil {
+			return fmt.Errorf("ПарсерВремя.Уст().фнЧасУст(): при установке секунд, ош=\n\t%w", ош)
+		}
+		стрМин := alias.Время(списВремя[1])
+		if ош := сам.мин.Уст(стрМин); ош != nil {
+			return fmt.Errorf("ПарсерВремя.Уст().фнЧасУст(): при установке минут, ош=\n\t%w", ош)
+		}
+		стрЧас := alias.Время(списВремя[0])
+		if ош := сам.час.Уст(стрЧас); ош != nil {
+			return fmt.Errorf("ПарсерВремя.Уст().фнЧасУст(): при установке часов, ош=\n\t%w", ош)
+		}
+
+		return nil
+	}
+
 	// Разбить время, перевести в секунды
-	lstTime := strings.Split(strTime, ":")
-	switch len(lstTime) {
+	switch len(списВремя) {
 	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)
+		стрСек := alias.Время(списВремя[0])
+		if ош := фнСекУст(стрСек); ош != nil {
+			return ош
 		}
 	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)
+		if ош := фнМинУст(); ош != nil {
+			return ош
 		}
 	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)
+		if ош := фнЧасУст(); ош != nil {
+			return ош
 		}
 	default:
-		return fmt.Errorf("ParseTime(): bad time val(%q)", strTime)
+		return fmt.Errorf("ПарсерВремя.Уст(): сбойная строка времени(%q)", стрВремя)
 	}
-	sf.всегоСек = int(sf.час.Получ()*3600) + sf.мин.Get()*60 + sf.сек.Get()
+	сам.всегоМилСек = сам.час.ПолучМилСек() + сам.мин.ПолучМилСек() + сам.сек.ПолучМилСек()
 	return nil
 }
 
-// Hour -- возвращает хранимые часы
-func (sf *ПарсерВремя) Час() types.ИПарсерЧас {
-	return sf.час
+// Час -- возвращает хранимые часы
+func (сам *ПарсерВремя) Час() types.ИПарсерЧас {
+	return сам.час
 }
 
-// Min -- возвращает хранимые минуты
-func (sf *ПарсерВремя) Min() *parsemin.ParseMin {
-	return sf.мин
+// Мин -- возвращает хранимые минуты
+func (сам *ПарсерВремя) Мин() types.ИПарсерМин {
+	return сам.мин
 }
 
-// Sec -- возвращает хранимые секунды
-func (sf *ПарсерВремя) Sec() *parsesec.ParseSec {
-	return sf.сек
+// Сек -- возвращает хранимые секунды
+func (сам *ПарсерВремя) Сек() types.ИПарсерСек {
+	return сам.сек
 }
 
 // String -- возвращает хранимое время

pkg/components/parser_time/parser_time_test.go

@@ -35,7 +35,7 @@ func (sf *tester) create() {
 	if sf.pars.сек == nil {
 		sf.t.Errorf("create(): sec==nil\n")
 	}
-	if val := sf.pars.ВсегоСек(); val != 0 {
+	if val := sf.pars.ПолучМилСек(); val != 0 {
 		sf.t.Errorf("create(): valInt(%d)!=0\n", val)
 	}
 	_ = sf.pars.String()
@@ -61,16 +61,16 @@ func (sf *tester) parseHourHourBad1() {
 	if err := sf.pars.Уст("-11:14:54"); err == nil {
 		sf.t.Errorf("parseHourHourBad1(): err==nil\n")
 	}
-	if val := sf.pars.ВсегоСек(); val != 5820 {
+	if val := sf.pars.ПолучМилСек(); val != 5820 {
 		sf.t.Errorf("parseHourHourBad1(): valInt(%d)!=5820\n", val)
 	}
 	if hour := sf.pars.Час().Получ(); hour != 1 {
 		sf.t.Errorf("parseHourHourBad1(): hour(%d)!=1\n", hour)
 	}
-	if min := sf.pars.Min().Get(); min != 14 {
+	if min := sf.pars.Мин().Получ(); min != 14 {
 		sf.t.Errorf("parseHourHourBad1(): min(%d)!=14\n", min)
 	}
-	if sec := sf.pars.Sec().Get(); sec != 54 {
+	if sec := sf.pars.Сек().Получ(); sec != 54 {
 		sf.t.Errorf("parseHourHourBad1(): sec(%d)!=54\n", sec)
 	}
 }
@@ -80,7 +80,7 @@ func (sf *tester) parseHourMinBad1() {
 	if err := sf.pars.Уст("01:-4:01"); err == nil {
 		sf.t.Errorf("parseHourMinBad1(): err==nil\n")
 	}
-	if val := sf.pars.ВсегоСек(); val != 5820 {
+	if val := sf.pars.ПолучМилСек(); val != 5820 {
 		sf.t.Errorf("parseHourMinBad1(): valInt(%d)!=5820\n", val)
 	}
 }
@@ -90,7 +90,7 @@ func (sf *tester) parseHourSecBad1() {
 	if err := sf.pars.Уст("01:37:a"); err == nil {
 		sf.t.Errorf("parseHourSecBad1(): err==nil\n")
 	}
-	if val := sf.pars.ВсегоСек(); val != 5820 {
+	if val := sf.pars.ПолучМилСек(); val != 5820 {
 		sf.t.Errorf("parseHourSecBad1(): valInt(%d)!=5820\n", val)
 	}
 }
@@ -100,7 +100,7 @@ func (sf *tester) parseHour() {
 	if err := sf.pars.Уст("01:37:00"); err != nil {
 		sf.t.Errorf("parseHour(): err=\n\t%v\n", err)
 	}
-	if val := sf.pars.ВсегоСек(); val != 5820 {
+	if val := sf.pars.ПолучМилСек(); val != 5820 {
 		sf.t.Errorf("parseHour(): valInt(%d)!=5820\n", val)
 	}
 }
@@ -110,7 +110,7 @@ func (sf *tester) parseMinMinBad1() {
 	if err := sf.pars.Уст("60:25"); err == nil {
 		sf.t.Errorf("parseMinMinBad1(): err==nil\n")
 	}
-	if val := sf.pars.ВсегоСек(); val != 444 {
+	if val := sf.pars.ПолучМилСек(); val != 444 {
 		sf.t.Errorf("parseMinMinBad1(): valInt(%d)!=444\n", val)
 	}
 }
@@ -120,7 +120,7 @@ func (sf *tester) parseMinSecBad1() {
 	if err := sf.pars.Уст("07:-1"); err == nil {
 		sf.t.Errorf("parseMinSecBad1(): err==nil\n")
 	}
-	if val := sf.pars.ВсегоСек(); val != 7*60+24 {
+	if val := sf.pars.ПолучМилСек(); val != 7*60+24 {
 		sf.t.Errorf("parseMinSecBad1(): valInt(%d)!=7*60+24\n", val)
 	}
 }
@@ -130,7 +130,7 @@ func (sf *tester) parseMin() {
 	if err := sf.pars.Уст("07:24"); err != nil {
 		sf.t.Errorf("parseMin(): err=\n\t%v\n", err)
 	}
-	if val := sf.pars.ВсегоСек(); val != 7*60+24 {
+	if val := sf.pars.ПолучМилСек(); val != 7*60+24 {
 		sf.t.Errorf("parseMin(): valInt(%d)!=7*60+24\n", val)
 	}
 }
@@ -141,7 +141,7 @@ func (sf *tester) parseSecBad1() {
 	if err := sf.pars.Уст("60"); err == nil {
 		sf.t.Errorf("parseSecBad1(): err==nil\n")
 	}
-	if val := sf.pars.ВсегоСек(); val != 28 {
+	if val := sf.pars.ПолучМилСек(); val != 28 {
 		sf.t.Errorf("parseSecBad1(): valInt(%d)!=28\n", val)
 	}
 }
@@ -151,7 +151,7 @@ func (sf *tester) parseSec() {
 	if err := sf.pars.Уст("28"); err != nil {
 		sf.t.Errorf("parseSec(): err=\n\t%v\n", err)
 	}
-	if val := sf.pars.ВсегоСек(); val != 28 {
+	if val := sf.pars.ПолучМилСек(); val != 28 {
 		sf.t.Errorf("parseSec(): valInt(%d)!=28\n", val)
 	}
 }

pkg/components/parser_time/parsesec/parsesec.go

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

pkg/components/product/product.go

@@ -31,11 +31,11 @@ func (сам *Продукт) Имя() types.ИБезопСтрока {
 }
 
 // Кол -- возвращает количество продукта
-func (сам *Продукт)Кол()types.ИБезопЦелое{
+func (сам *Продукт) Кол() types.ИБезопЦелое {
 	return сам.кол
 }
 
 // Время -- возвращает время производства
-func (сам *Продукт)Время()types.ИПарсерВремя{
+func (сам *Продукт) Время() types.ИПарсерВремя {
 	return сам.время
-}
+}

pkg/components/safe_int/safe_int.go

@@ -1,6 +1,10 @@
 package safe_int
 
-import "sync"
+import (
+	"sync"
+
+	"wartank/pkg/types"
+)
 
 /*
 	Потокобезопасное целое
@@ -8,25 +12,34 @@ import "sync"
 
 // БезопЦелое -- потокобезопасное целое
 type БезопЦелое struct {
-	знач   int
+	знач int
 	блок sync.RWMutex
 }
 
 // НовБезопЦелое -- возвращает новый *БезопЦелое
 func НовБезопЦелое() *БезопЦелое {
-	return &БезопЦелое{}
+	сам := &БезопЦелое{}
+	_ = types.ИСбрасыватель(сам)
+	return сам
+}
+
+// Сброс -- сбрасывает в исходное значение
+func (сам *БезопЦелое) Сброс() {
+	сам.блок.Lock()
+	defer сам.блок.Unlock()
+	сам.знач = 0
 }
 
 // Получ -- возвращает хранимое значение
-func (sf *БезопЦелое) Получ() int {
-	sf.блок.RLock()
-	defer sf.блок.RUnlock()
-	return sf.знач
+func (сам *БезопЦелое) Получ() int {
+	сам.блок.RLock()
+	defer сам.блок.RUnlock()
+	return сам.знач
 }
 
 // Уст -- устанавливает хранимое значение
-func (sf *БезопЦелое) Уст(val int) {
-	sf.блок.Lock()
-	defer sf.блок.Unlock()
-	sf.знач = val
+func (сам *БезопЦелое) Уст(val int) {
+	сам.блок.Lock()
+	defer сам.блок.Unlock()
+	сам.знач = val
 }

pkg/components/safe_string/safe_string.go

@@ -8,7 +8,7 @@ import "sync"
 
 // БезопСтрока -- потокобезопасная строка
 type БезопСтрока struct {
-	знач   string
+	знач string
 	блок sync.RWMutex
 }
 

pkg/components/section/down_time/down_time.go

@@ -9,6 +9,7 @@ import (
 	"sync"
 	"time"
 
+	"wartank/pkg/alias"
 	"wartank/pkg/components/parser_time"
 	"wartank/pkg/components/safe_bool"
 	"wartank/pkg/components/safe_int"
@@ -21,12 +22,12 @@ const (
 
 // ВремОбрат -- счётчик обратного времени для игровой зоны (анга, база, битва и т.п.)
 type ВремОбрат struct {
-	сцена types.ИСцена
+	сцена types.ИСцена // Сцена, которой принадлежит отсчёт времени
 
-	время types.ИПарсерВремя // Парсер значения
+	остатПарсер types.ИПарсерВремя // Парсер значения (мсек)
 
-	времяЗнач    *safe_int.БезопЦелое // Фактическое значение счётчика
-	времПорог    *safe_int.БезопЦелое // Целевое время срабатывания
+	остатЗнач    *safe_int.БезопЦелое // Фактическое значение счётчика в мсек
+	порогЗнач    *safe_int.БезопЦелое // Целевое время срабатывания в мсек
 	еслиРаботает *safe_bool.БезопБул  // Признак работы
 
 	канТик   chan int // Канал секундных интервалов сна (для отображения)
@@ -39,141 +40,121 @@ type ВремОбрат struct {
 }
 
 // НовВремОбрат -- возвращает новый *CountTime
-func НовВремОбрат(сцена types.ИСцена, знач int) *ВремОбрат {
+func НовВремОбрат(сцена types.ИСцена, время alias.МилСек) *ВремОбрат {
 	if сцена == nil {
 		panic("НовВремОбрат(): ИСцена == nil")
 	}
 	кнт, фнОтмена := context.WithCancel(сцена.Кнт())
 	сам := &ВремОбрат{
 		сцена:        сцена,
-		времяЗнач:    safe_int.НовБезопЦелое(),
+		остатЗнач:    safe_int.НовБезопЦелое(),
 		канТик:       make(chan int, 5),
 		канВызов:     make(chan int, 2),
 		еслиРаботает: safe_bool.НовБезопБул(),
-		время:        parser_time.НовПарсерВремя(),
-		времПорог:    safe_int.НовБезопЦелое(),
+		остатПарсер:  parser_time.НовПарсерВремя(),
+		порогЗнач:    safe_int.НовБезопЦелое(),
 		кнт:          кнт,
 		фнОтмена:     фнОтмена,
 	}
-	знач = int(time.Now().UTC().Unix()) + знач
-	сам.времПорог.Уст(знач)
+	мСек := alias.МилСек(time.Now().UTC().UnixMilli()) + время
+	сам.порогЗнач.Уст(int(мСек))
 	сам.еслиРаботает.Уст()
 	go сам.сделатьТик()
 	go сам.пуск()
 	go сам.закрыть()
+	_ = types.ИВремяОстат(сам)
 	return сам
 }
 
-// Запускает тикер для секундных интервалов
+// ПолучМилСек -- возвращает оставшееся хранимое время остатка
+func (сам *ВремОбрат) ПолучМилСек() alias.МилСек {
+	return сам.остатПарсер.ПолучМилСек()
+}
+
+// Запускает тикер для интервалов сна (через каждые 100 мСек)
 func (сам *ВремОбрат) сделатьТик() {
-	спатьСчёт := 0 // Счётчик сна (10 периодов -- 1 секунда)
 	defer close(сам.канТик)
 	for {
 		select {
-		case <-сам.кнт.Done(): // Отмена контекста бота
-			// log._rintf("CountTime.makeTick(): отмена контекста бота\n")
+		case <-сам.кнт.Done(): // Отмена контекста тикера (а может и сцены, может и бота)
 			return
 		default:
+			time.Sleep(спатьИнтервал)
 			if !сам.еслиРаботает.Получ() {
 				сам.фнОтмена()
 				return
 			}
-
-			if спатьСчёт >= 10 {
-				сам.канТик <- 1
-				спатьСчёт = 0
+			timeNow := time.Now().UTC().Unix()
+			if сам.порогЗнач.Получ() < int(timeNow) {
+				continue
 			}
-			time.Sleep(спатьИнтервал)
-			спатьСчёт++
+			сам.канТик <- 1
+			сам.фнОтмена()
+			сам.еслиРаботает.Сброс()
+			return
 		}
 	}
 }
 
 // Главный цикл обратного отсчёта
-func (sf *ВремОбрат) пуск() {
-	for range sf.канТик {
-		time.Sleep(time.Millisecond * 100)
-		timeNow := time.Now().UTC().Unix()
-		if sf.времПорог.Получ() > int(timeNow) {
-			continue
-		}
-		close(sf.канВызов)
-		sf.фнОтмена()
+func (сам *ВремОбрат) пуск() {
+	for range сам.канТик {
+		close(сам.канВызов)
+		сам.фнОтмена()
 		return
 	}
 }
 
-// Стоп -- останавливает работу cчётчика
-func (sf *ВремОбрат) Стоп() {
-	sf.еслиРаботает.Сброс()
+// Сброс -- сбрасывает оставшееся время в ноль
+func (сам *ВремОбрат) Сброс() {
+	сам.остатПарсер.Сброс()
+	сам.остатЗнач.Сброс()
+	сам.порогЗнач.Сброс()
 }
 
-// Получ -- возвращает число оставшихся сек
-func (sf *ВремОбрат) Получ() int {
-	return sf.времяЗнач.Получ()
+// Стоп -- останавливает работу cчётчика
+func (сам *ВремОбрат) Стоп() {
+	сам.фнОтмена()
 }
 
-// устанавливает число оставшихся сек
-func (sf *ВремОбрат) parse(val string) error {
-	sf.блок.Lock()
-	defer sf.блок.Unlock()
-	if val == "" {
-		return fmt.Errorf("CountTime.parse(): val is empty")
+// Уст -- устанавливает число оставшихся сек
+func (сам *ВремОбрат) Уст(время alias.Время) error {
+	сам.блок.Lock()
+	defer сам.блок.Unlock()
+	if ош := сам.остатПарсер.Уст(время); ош != nil {
+		return fmt.Errorf("ВремОбрат(): ошибка при установке времени, ош=\n\t%w", ош)
 	}
-	sf.время.Уст(val)
-	_val := sf.время.Hour().Get()*3600 + sf.время.Min().Get()*60 + sf.время.Min().Get()
-	sf.времяЗнач.Уст(_val)
-	_val = int(time.Now().UTC().Unix()) + sf.времяЗнач.Получ()
-	sf.времПорог.Уст(_val)
+	_val := сам.остатПарсер.ПолучМилСек()
+	сам.остатЗнач.Уст(int(_val))
+	val := int(time.Now().UTC().UnixMilli()) + сам.остатЗнач.Получ()
+	сам.порогЗнач.Уст(val)
 	return nil
 }
 
 // устанавливает число оставшихся сек
-func (sf *ВремОбрат) set_val(val int) error {
-	sf.блок.Lock()
-	defer sf.блок.Unlock()
+func (сам *ВремОбрат) set_val(val int) error {
+	сам.блок.Lock()
+	defer сам.блок.Unlock()
 	if val < 0 {
 		return fmt.Errorf("CountTime.set_val(): val(%v)<0", val)
 	}
-	sf.времяЗнач.Уст(val)
-	{ // Обновить локальные счётчики
-		if val < 60 {
-			sf.время.Hour().Reset()
-			sf.время.Min().Reset()
-			sf.время.Sec().Set(val)
-			return nil
-		}
-		if 60 < val && val < 3600 {
-			sf.время.Hour().Reset()
-			iMin := val / 60
-			sf.время.Min().Set(iMin)
-			val -= iMin * 60
-			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)
-		// val = int(time.Now().UTC().Unix()) + sf.val.Get()
-	}
+	сам.остатЗнач.Уст(val)
 	return nil
 }
 
-// Стр -- возвращает строковое представление оставшихся сек
-func (sf *ВремОбрат) Стр() string {
-	sf.блок.RLock()
-	defer sf.блок.RUnlock()
+// String -- возвращает строковое представление оставшихся сек
+func (сам *ВремОбрат) String() string {
+	сам.блок.RLock()
+	defer сам.блок.RUnlock()
 	timeNow := time.Now().UTC().Unix()
-	val := sf.времПорог.Получ() - int(timeNow)
-	go sf.set_val(val)
-	return sf.время.String()
+	val := сам.порогЗнач.Получ() - int(timeNow)
+	go сам.set_val(val)
+	return сам.остатПарсер.String()
 }
 
 // КаналСиг -- возвращает канал чтения тиков
-func (sf *ВремОбрат) КаналСиг() <-chan int {
-	return sf.канВызов
+func (сам *ВремОбрат) КаналСиг() <-chan int {
+	return сам.канВызов
 }
 
 func (сам *ВремОбрат) закрыть() {

pkg/components/section/down_time/down_time_test.go

@@ -3,6 +3,7 @@ package down_time
 import (
 	"testing"
 	"time"
+	"wartank/pkg/alias"
 	"wartank/pkg/components/safe_bool"
 	"wartank/pkg/mock/mock_zone"
 	"wartank/pkg/mock/mockapp"
@@ -62,38 +63,38 @@ func (sf *tester) cancel() {
 func (sf *tester) checkTick() {
 	времОбрат := НовВремОбрат(sf.zone, 0)
 	{ // Секундный тик
-		времОбрат.parse("00:00:08")
+		времОбрат.Уст("00:00:08")
 		time.Sleep(time.Second * 1)
 		времОбрат.канТик <- 1
 		time.Sleep(time.Millisecond * 20)
-		if val := времОбрат.Стр(); val != "00:00:08" {
+		if val := времОбрат.String(); val != "00:00:08" {
 			sf.t.Errorf("checkTick(): счётчик(%v)!='00:00:08'", val)
 		}
 	}
 	{ // Проверка времени прямо сейчас
 		времОбрат.канТик <- 1
 		time.Sleep(time.Millisecond * 20)
-		if val := времОбрат.Стр(); val != "00:00:08" {
+		if val := времОбрат.String(); val != "00:00:08" {
 			sf.t.Errorf("checkTick(): счётчик(%v)!='00:00:08'", val)
 		}
 	}
 	{ // Проверка обратного вызова прямо сейчас
-		strTime := time.Now().UTC().Format("15:04:05")
-		времОбрат.parse(strTime)
-		if val := времОбрат.Стр(); val != strTime {
+		strTime := alias.Время(time.Now().UTC().Format("15:04:05"))
+		времОбрат.Уст(strTime)
+		if val := времОбрат.String(); val != string(strTime) {
 			sf.t.Errorf("checkTick(): счётчик(%v)!=%s", val, strTime)
 		}
 		времОбрат.канТик <- 1
 		// Выход из функции -- и есть факт обратного вызова
 		sf.call()
 		{ // Проверка отсутствия обратного вызова прямо сейчас
-			времОбрат.parse("00:00:00")
+			времОбрат.Уст("00:00:00")
 			времОбрат.блок.Lock()
 			времОбрат.канТик <- 1
 			времОбрат.блок.Unlock()
 			// Выход из функции -- и есть факт обратного вызова
 			sf.call()
-			if val := времОбрат.Получ(); val != 0 {
+			if val := времОбрат.ПолучМилСек(); val != 0 {
 				sf.t.Errorf("checkTick(): счётчик(%v)!=0", val)
 			}
 			времОбрат.Стоп()
@@ -103,13 +104,13 @@ func (sf *tester) checkTick() {
 	}
 }
 
-func (sf *tester) setStrBad1(strBad string) {
+func (sf *tester) setStrBad1(strBad alias.Время) {
 	defer func() {
 		if _panic := recover(); _panic == nil {
 			sf.t.Errorf("setStrBad1(): panic==nil\n")
 		}
 	}()
-	if sf.err = sf.ct.parse(strBad); sf.err == nil {
+	if sf.err = sf.ct.Уст(strBad); sf.err == nil {
 		sf.t.Errorf("setStrBad1(): BAD-2 err==nil")
 	}
 }
@@ -119,7 +120,7 @@ func (sf *tester) setStr() {
 	go sf.call()
 	ct := НовВремОбрат(sf.zone, 0)
 	{ // BAD-1 пустая строка
-		if sf.err = ct.parse(""); sf.err == nil {
+		if sf.err = ct.Уст(""); sf.err == nil {
 			sf.t.Errorf("setStr(): BAD-1 err==nil")
 		}
 	}
@@ -152,17 +153,17 @@ func (sf *tester) setStr() {
 	// BAD-15 кривые часы +минуты + секунды
 	//sf.setStrBad1("24:02:03")
 	{ // GOOD-1 секунды
-		if sf.err = ct.parse("03"); sf.err != nil {
+		if sf.err = ct.Уст("03"); sf.err != nil {
 			sf.t.Errorf("setStr(): GOOD-1 err=%v", sf.err)
 		}
 	}
 	{ // GOOD-2 минуты секунды
-		if sf.err = ct.parse("02:03"); sf.err != nil {
+		if sf.err = ct.Уст("02:03"); sf.err != nil {
 			sf.t.Errorf("setStr(): GOOD-2 err=%v", sf.err)
 		}
 	}
 	{ // GOOD-3 часы минуты секунды
-		if sf.err = ct.parse("01:02:03"); sf.err != nil {
+		if sf.err = ct.Уст("01:02:03"); sf.err != nil {
 			sf.t.Errorf("setStr(): GOOD-3 err=%v", sf.err)
 		}
 	}
@@ -182,16 +183,16 @@ 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.остатПарсер.Час().Получ() != 0 {
+			sf.t.Errorf("setInt(): GOOD-1 hour(%v)!=0", sf.ct.остатПарсер.Час().Получ())
 		}
-		if ct.время.Min().Get() != 0 {
-			sf.t.Errorf("setInt(): GOOD-1 min(%v)!=0", sf.ct.время.Min().Get())
+		if ct.остатПарсер.Мин().Получ() != 0 {
+			sf.t.Errorf("setInt(): GOOD-1 min(%v)!=0", sf.ct.остатПарсер.Мин().Получ())
 		}
-		if ct.время.Sec().Get() != 8 {
-			sf.t.Errorf("setInt(): GOOD-1 sec(%v)!=8", sf.ct.время.Sec().Get())
+		if ct.остатПарсер.Сек().Получ() != 8 {
+			sf.t.Errorf("setInt(): GOOD-1 sec(%v)!=8", sf.ct.остатПарсер.Сек().Получ())
 		}
-		if strVal := ct.Стр(); strVal != "00:00:08" {
+		if strVal := ct.String(); strVal != "00:00:08" {
 			sf.t.Errorf("setInt(): GOOD-1 strVal(%v)!='00:00:08'", strVal)
 		}
 	}
@@ -199,16 +200,16 @@ 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.остатПарсер.Час().Получ() != 0 {
+			sf.t.Errorf("setInt(): GOOD-2 hour(%v)!=0", sf.ct.остатПарсер.Час().Получ())
 		}
-		if ct.время.Min().Get() != 2 {
-			sf.t.Errorf("setInt(): GOOD-2 min(%v)!=2", sf.ct.время.Min().Get())
+		if ct.остатПарсер.Мин().Получ() != 2 {
+			sf.t.Errorf("setInt(): GOOD-2 min(%v)!=2", sf.ct.остатПарсер.Мин().Получ())
 		}
-		if ct.время.Sec().Get() != 1 {
-			sf.t.Errorf("setInt(): GOOD-2 sec(%v)!=1", sf.ct.время.Sec().Get())
+		if ct.остатПарсер.Сек().Получ() != 1 {
+			sf.t.Errorf("setInt(): GOOD-2 sec(%v)!=1", sf.ct.остатПарсер.Сек().Получ())
 		}
-		if strVal := ct.Стр(); strVal != "00:02:01" {
+		if strVal := ct.String(); strVal != "00:02:01" {
 			sf.t.Errorf("setInt(): GOOD-2 strVal(%v)!='00:02:01'", strVal)
 		}
 	}
@@ -216,16 +217,16 @@ 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.остатПарсер.Час().Получ() != 2 {
+			sf.t.Errorf("setInt(): GOOD-3 hour(%v)!=2", sf.ct.остатПарсер.Час().Получ())
 		}
-		if ct.время.Min().Get() != 0 {
-			sf.t.Errorf("setInt(): GOOD-3 min(%v)!=0", sf.ct.время.Min().Get())
+		if ct.остатПарсер.Мин().Получ() != 0 {
+			sf.t.Errorf("setInt(): GOOD-3 min(%v)!=0", sf.ct.остатПарсер.Мин().Получ())
 		}
-		if ct.время.Sec().Get() != 3 {
-			sf.t.Errorf("setInt(): GOOD-3 sec(%v)!=3", sf.ct.время.Sec().Get())
+		if ct.остатПарсер.Сек().Получ() != 3 {
+			sf.t.Errorf("setInt(): GOOD-3 sec(%v)!=3", sf.ct.остатПарсер.Сек().Получ())
 		}
-		if strVal := ct.Стр(); strVal != "02:00:03" {
+		if strVal := ct.String(); strVal != "02:00:03" {
 			sf.t.Errorf("setInt(): GOOD-3 strVal(%v)!='02:00:03'", strVal)
 		}
 	}
@@ -256,7 +257,7 @@ func (sf *tester) createGood1() {
 	if ct == nil {
 		sf.t.Errorf("createGood1(): countTime==nil")
 	}
-	if val := ct.Получ(); val != 0 {
+	if val := ct.ПолучМилСек(); val != 0 {
 		sf.t.Errorf("createGood1(): val(%v)!=0", val)
 	}
 }

pkg/components/section/section.go

@@ -6,6 +6,7 @@ import (
 	"log"
 	"sync"
 
+	"wartank/pkg/alias"
 	"wartank/pkg/components/lst_string"
 	"wartank/pkg/components/parser_time"
 	"wartank/pkg/components/section/down_time"
@@ -23,21 +24,21 @@ type Секция struct {
 	блок      sync.RWMutex
 }
 
-// NewSection -- возвращает новую секцию игры
-func NewSection(bot types.ИБот, zoneName, strControl string) (*Секция, error) {
-	log.Printf("NewSection(): strControl=%q\n", strControl)
-	zone, err := zone.NewZone(bot, zoneName)
+// НовСекция -- возвращает новую секцию игры
+func НовСекция(бот types.ИБот, зонаИмя, стрКонтроль string) (*Секция, error) {
+	log.Printf("НовСекция(): стрКонтроль=%q\n", стрКонтроль)
+	zone, err := zone.NewZone(бот, зонаИмя)
 	if err != nil {
-		return nil, fmt.Errorf("NewSection(): in create IZone, err=\n\t%w", err)
+		return nil, fmt.Errorf("НовСекция(): in create IZone, err=\n\t%w", err)
 	}
 	sf := &Секция{
 		Zone:      zone,
 		countDown: down_time.НовВремОбрат(zone, 5),
 		mode:      section_mode.NewSectionMode(),
 	}
-	sf.lstString, err = lst_string.NewLstString(strControl)
+	sf.lstString, err = lst_string.NewLstString(стрКонтроль)
 	if err != nil {
-		return nil, fmt.Errorf("NewSection(): in create *LstString, err=\n\t%w", err)
+		return nil, fmt.Errorf("НовСекция(): in create *LstString, err=\n\t%w", err)
 	}
 	return sf, nil
 }
@@ -55,23 +56,24 @@ func (sf *Секция) СписПолучить() []string {
 	return sf.lstString.Get()
 }
 
-// SetCountDown -- устанавливает новое значение обратного счётчика времени (int)
-func (сам *Секция) SetCountDown(sec int) error {
+// ОбратВремяУст -- устанавливает новое значение обратного счётчика времени (int)
+func (сам *Секция) ОбратВремяУст(время alias.МилСек) error {
 	сам.блок.Lock()
 	defer сам.блок.Unlock()
-	сам.countDown = down_time.НовВремОбрат(сам, sec)
+	сам.countDown = down_time.НовВремОбрат(сам, время)
 	// if err := sf.countDown.Set(sec); err != nil {
-	// 	return fmt.Errorf("Section.SetCountDown(): err=\n\t%w", err)
+	// 	return fmt.Errorf("Секция.ОбратВремяУст(): err=\n\t%w", err)
 	// }
 	return nil
 }
 
 // ParseCountDown -- устанавливает новое значение обратного счётчика времени (string)
-func (sf *Секция) ParseCountDown(sec string) error {
-	pt := parser_time.НовПарсерВремя()
-	pt.Parse(sec)
-	_sec := pt.Get()
-	sf.countDown = down_time.НовВремОбрат(sf, _sec)
+func (sf *Секция) ParseCountDown(времяСек alias.Время) error {
+	var pt types.ИПарсерВремя
+	pt = parser_time.НовПарсерВремя()
+	pt.Уст(времяСек)
+	милСек := pt.ПолучМилСек()
+	sf.countDown = down_time.НовВремОбрат(sf, милСек)
 	// if err := sf.countDown.Set(sec); err != nil {
 	// 	return fmt.Errorf("Section.SetCountDown(): err=\n\t%w", err)
 	// }

pkg/types/icounttime.go

@@ -6,16 +6,7 @@ package types
 
 // ИВремяОстат -- нтерфейс к счётчику оставшегося времени
 type ИВремяОстат interface {
-	// Parse -- устанавливает интервал времени
-	// Parse(string) error
-	// Set -- устанавливает интервал времени из числа секунд
-	// Set(int) error
-	// Получ -- возвращает оставшееся время
-	Получ() int
-	// Стр -- возвращает стороковое представление оставшегося времени
-	Стр() string
-	// Стоп -- останавливает работу отсчёта
-	Стоп()
+	ИПарсерПростой
 	// КаналСиг -- возвращает канал тиков
 	КаналСиг() <-chan int
 }

pkg/types/iparser_hour.go

@@ -4,6 +4,7 @@ import "wartank/pkg/alias"
 
 // ИПарсерЧас --парсер часов
 type ИПарсерЧас interface {
+	ИПарсерПростой
 	// Получ -- возвращает числовое значение часа
 	Получ() alias.Час
 }

pkg/types/iparser_min.go

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

pkg/types/iparser_sec.go

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

pkg/types/iparser_simple.go

@@ -1,9 +1,15 @@
 package types
 
+import "wartank/pkg/alias"
+
 // ИПарсерПростой -- базовый интерфейс парсеру времени
 type ИПарсерПростой interface {
 	// Уст -- устанавливает часы
-	Уст(string) error
+	Уст(alias.Время) error
+	// Сброс -- сбраасывает хранимое значение
+	Сброс()
 	// String -- возвращает строковое представление
 	String() string
+	// ПолучМилСек -- возвращает хранимое количество мсек
+	ПолучМилСек() alias.МилСек
 }

pkg/types/iparser_time.go

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

pkg/types/ireset.go

@@ -0,0 +1,7 @@
+package types
+
+// ИСбрасыватель -- сбрасывает в исходное значение тип
+type ИСбрасыватель interface {
+	// Сброс -- сбрасывает в исходное значение
+	Сброс()
+}

pkg/types/isafe_string.go

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

server/serv_bots/warbot/angar/angar.go

@@ -56,7 +56,7 @@ type Ангар struct {
 
 // НовАнгар -- возвращает новый *Angar
 func НовАнгар(bot types.ИБот) (*Ангар, error) {
-	section, err := section.NewSection(bot, "Ангар", `<title>Ангар</title>`)
+	section, err := section.НовСекция(bot, "Ангар", `<title>Ангар</title>`)
 	if err != nil {
 		return nil, fmt.Errorf("НовАнгар(): in create ISection, err=\n\t%w", err)
 	}
@@ -188,7 +188,7 @@ func (sf *Ангар) Пуск() error {
 	фнЦикл := func() bool {
 		sf.Обновить()
 		// sf.конвойПроверить()
-		if err := sf.Секция.SetCountDown(60); err != nil {
+		if err := sf.Секция.ОбратВремяУст(60); err != nil {
 			sf.Закончить()
 			logrus.WithError(err).Errorln("Ангар.Run(): in update ICountTime")
 			return false
@@ -196,11 +196,10 @@ func (sf *Ангар) Пуск() error {
 		return true
 	}
 	go func() {
-		sf.SetCountDown(1)
+		sf.Секция.ОбратВремяУст(1)
 		for {
 			select {
 			case <-sf.бот.Кнт().Done(): // Отмена контекста
-				sf.ВремяОпрос().Стоп()
 				return
 			case <-sf.ВремяОпрос().КаналСиг(): // Метка времени
 				if !фнЦикл() {

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

@@ -31,7 +31,7 @@ type Оружейная struct {
 
 // НовОружейная -- возвращает новый *Arsenal
 func НовОружейная(base types.ИБаза) (*Оружейная, error) {
-	section, err := section.NewSection(base.Бот(), "Арсенал", `<span class="green2">Ремкомплект</span><br/>`)
+	section, err := section.НовСекция(base.Бот(), "Арсенал", `<span class="green2">Ремкомплект</span><br/>`)
 	if err != nil {
 		return nil, fmt.Errorf("НовОружейная(): in create ISection, err=\n\t%w", err)
 	}

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

@@ -7,6 +7,7 @@ import (
 	"strings"
 	"time"
 
+	"wartank/pkg/alias"
 	"wartank/pkg/components/section"
 	"wartank/pkg/types"
 	"wartank/server/serv_bots/warbot/angar/base/bank/bankmode"
@@ -29,7 +30,7 @@ type Банк struct {
 
 // НовБанк -- возвращает новый *Bank
 func НовБанк(база types.ИБаза) (*Банк, error) {
-	section, ош := section.NewSection(база.Бот(), "Банк", `<span class="green2">Серебро</span><br/>`)
+	section, ош := section.НовСекция(база.Бот(), "Банк", `<span class="green2">Серебро</span><br/>`)
 	if ош != nil {
 		return nil, fmt.Errorf("НовБанк(): при создании секции банка, ош=\n\t%w", ош)
 	}
@@ -196,7 +197,7 @@ func (sf *Банк) СереброБот() types.ИСтатПарам {
 }
 
 // Запускает в производство серебро
-func (sf *Банк) сделатьСеребро() (int, error) {
+func (sf *Банк) сделатьСеребро() (alias.МилСек, error) {
 	var (
 		lstBank = sf.СписПолучить()
 		ind     int
@@ -224,7 +225,7 @@ func (sf *Банк) сделатьСеребро() (int, error) {
 		strLink = "https://wartank.ru/production/" + lstLink[0]
 		lstBank, err := sf.сеть.Get(strLink)
 		if err != nil {
-			return -1, fmt.Errorf("BankNet.makeProduct(): при выполнении GET-запроса начать производство, err=%w", err)
+			return 0, fmt.Errorf("BankNet.makeProduct(): при выполнении GET-запроса начать производство, err=%w", err)
 		}
 		for _, strOut := range lstBank {
 			if strings.Contains(strOut, `<title>База</title>`) { // Это база, а не банк
@@ -232,13 +233,13 @@ func (sf *Банк) сделатьСеребро() (int, error) {
 			}
 		}
 		if err = sf.СтрОбновить(lstBank); err != nil {
-			return -1, fmt.Errorf("BankNet.makeProduct(): при обновлении lstBank, err=%w", err)
+			return 0, fmt.Errorf("BankNet.makeProduct(): при обновлении lstBank, err=%w", err)
 		}
-		if err := sf.ParseCountDown(time1); err != nil {
+		if err := sf.ParseCountDown(alias.Время(time1)); err != nil {
 			log.Printf("WARN Банк.makeProduct(): при установке времени производства банка(%v)\n\terr=%v\n", time1, err)
 		}
 	}
-	return sf.ВремяОпрос().Получ(), nil
+	return sf.ВремяОпрос().ПолучМилСек(), nil
 }
 
 // Получает все режимы банка

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

@@ -8,6 +8,7 @@ import (
 	"sync"
 	"time"
 
+	"wartank/pkg/alias"
 	"wartank/pkg/components/section"
 	"wartank/pkg/components/sound"
 	"wartank/pkg/types"
@@ -24,8 +25,8 @@ import (
 */
 
 const (
-	времОжидПлат    = 60   // Время ожидания платного ускорения
-	времОжидБесплат = 1810 // Время ожидания бесплатного ускорения
+	времОжидПлат    = 60 * 1_000   // Время ожидания платного ускорения
+	времОжидБесплат = 1810 * 1_000 // Время ожидания бесплатного ускорения
 
 )
 
@@ -44,7 +45,7 @@ type База struct {
 
 // НовБаза -- возвращает новую базу бота
 func НовБаза(ангар types.ИАнгар) (*База, error) {
-	section, err := section.NewSection(ангар.Бот(), "База", `<title>База</title>`)
+	section, err := section.НовСекция(ангар.Бот(), "База", `<title>База</title>`)
 	if err != nil {
 		return nil, fmt.Errorf("NewBase(): in create ISection, err=\n\t%w", err)
 	}
@@ -119,7 +120,6 @@ func (sf *База) пуск() {
 	for {
 		select {
 		case <-sf.Кнт().Done():
-			sf.ВремяОпрос().Стоп()
 			return
 		// case <-sf.ВремяОпрос().КаналСиг():
 		// 	фнЦикл()
@@ -154,24 +154,24 @@ func (sf *База) runComponent() error {
 
 // Выбирает время обновления базы по компонентам
 func (sf *База) setCountDown() {
-	timeBase := sf.банк.ВремяОпрос().Получ()
+	timeBase := sf.банк.ВремяОпрос().ПолучМилСек()
 	timeCount := timeBase
-	timeArsenal := sf.арсенал.ВремяОпрос().Получ()
-	timeMine := sf.шахта.ВремяОпрос().Получ()
+	timeArsenal := sf.арсенал.ВремяОпрос().ПолучМилСек()
+	timeMine := sf.шахта.ВремяОпрос().ПолучМилСек()
 	if timeArsenal < timeCount {
 		timeCount = timeArsenal
 	}
 	if timeMine < timeCount {
 		timeCount = timeMine
 	}
-	if timeCount <= 1 {
+	if timeCount <= 1*1_000 {
 		sf.времОстат = 5
 		return
 	}
-	if timeCount > (600) {
+	if timeCount > (600 * 1_000) {
 		sf.времОстат = 600
 	}
-	sf.SetCountDown(timeCount)
+	sf.Секция.ОбратВремяУст(timeCount)
 }
 
 // Арсенал -- возвращает объект арсенала
@@ -241,7 +241,7 @@ func (sf *База) checkMineTime() {
 	strTime := lstTime[1]
 	lstTime = strings.Split(strTime, `</span></span></div></td>`)
 	strTime = lstTime[0]
-	if err := sf.шахта.ParseCountDown(strTime); err != nil {
+	if err := sf.шахта.ParseCountDown(alias.Время(strTime)); err != nil {
 		log.Printf("ERRO Base.checkMineTime(): при установке обратного отсчёта(%v), err=\n\t%v\n", strTime, err)
 	}
 }
@@ -349,7 +349,7 @@ func (sf *База) шахтаСтатаОбновить() {
 			strTime := lstTime[1]
 			lstTime = strings.Split(strTime, `</span></span></div></td>`)
 			strTime = lstTime[0]
-			if err := sf.шахта.ParseCountDown(strTime); err != nil {
+			if err := sf.шахта.ParseCountDown(alias.Время(strTime)); err != nil {
 				log.Printf("ERRO Base.checkMineStat(): при установке времени ожидания шахты(%v)\n\terr=%v\n", strTime, err)
 			}
 		}
@@ -434,7 +434,7 @@ func (sf *База) проверитьАрсеналВремя() {
 	strTime := lstTime[1]
 	lstTime = strings.Split(strTime, `</span></span></div></td>`)
 	strTime = lstTime[0]
-	if err := sf.арсенал.ParseCountDown(strTime); err != nil {
+	if err := sf.арсенал.ParseCountDown(alias.Время(strTime)); err != nil {
 		log.Printf("ERRO Base.checkArsenalTime(): при установке времени ожидания арсенала(%v)\n\terr=%v\n", strTime, err)
 	}
 }
@@ -488,7 +488,7 @@ func (sf *База) проверитьАрсеналУскорение() {
 		}
 		{ // Платное ускорение
 			if strings.Contains(strOut, `Ускорить за`) {
-				if err := sf.арсенал.SetCountDown(времОжидПлат); err != nil {
+				if err := sf.арсенал.ОбратВремяУст(времОжидПлат); err != nil {
 					log.Printf("WARN Base.checkArsenalForce(): при установке платного времени ускорения апгрейда арсенала(%v)\n\terr=%v\n", времОжидПлат, err)
 				}
 				sf.арсенал.РежимТекущ().Уст("upgrade")
@@ -531,7 +531,7 @@ func (sf *База) проверитьАрсеналУскорение() {
 		}
 		sf.арсенал.РежимТекущ().Уст("upgrade")
 		sf.арсенал.РежимТекущ().РежимУст("апгрейд")
-		if err := sf.арсенал.SetCountDown(времОжидБесплат); err != nil {
+		if err := sf.арсенал.ОбратВремяУст(времОжидБесплат); err != nil {
 			log.Printf("WARN Base.checkArsenalForce(): при установке бесплатного времени ускорения апгрейда арсенала(%v)\n\terr=%v\n", времОжидБесплат, err)
 		}
 	}
@@ -545,8 +545,8 @@ func (sf *База) проверитьБанк() error {
 		sf.checkBankMode()
 	}
 	sf.checkBankTime() // Проверка времени ожидания
-	countTime := sf.банк.ВремяОпрос().Получ()
-	if countTime > 5 {
+	countTime := sf.банк.ВремяОпрос().ПолучМилСек()
+	if countTime > 5_000 {
 		return nil
 	}
 	sf.checkBankForce() // Нужно ли ускорить апгрейд банка
@@ -608,7 +608,7 @@ func (sf *База) checkBankTime() {
 	strTime := lstTime[1]
 	lstTime = strings.Split(strTime, `</span></span></div></td>`)
 	strTime = lstTime[0]
-	if err := sf.банк.ParseCountDown(strTime); err != nil {
+	if err := sf.банк.ParseCountDown(alias.Время(strTime)); err != nil {
 		log.Printf("ERRO Base.checkBankTime(): при установке времени ожидания банка(%v)\n\terr=%v\n", strTime, err)
 	}
 }
@@ -636,7 +636,7 @@ func (sf *База) checkBankProduct() {
 		return
 	}
 	sf.банк.UpdateLst()
-	sf.банк.SetCountDown(1)
+	sf.банк.ОбратВремяУст(1_1000)
 }
 
 // Проверка получения серебра из банка
@@ -683,13 +683,13 @@ func (sf *База) checkBankTake() {
 		if err := sf.банк.СтрОбновить(lstBank); err != nil {
 			log.Printf("ERRO Base.checkBankTake(): при установке lstBank, err=\n\t%v'n", err)
 		}
-		sf.банк.SetCountDown(1)
+		sf.банк.ОбратВремяУст(1_000)
 		return
 	}
 	if err := sf.СтрОбновить(lstBank); err != nil {
 		log.Printf("ERRO Base.checkBankTake(): при установке lstBase, err=\n\t%v'n", err)
 	}
-	sf.банк.SetCountDown(1)
+	sf.банк.ОбратВремяУст(1_000)
 }
 
 // Проверяет на ускорение апгрейда банка
@@ -711,7 +711,7 @@ func (sf *База) checkBankForce() {
 			}
 		}
 		if isOut && strings.Contains(strOut, `Ускорить за`) {
-			if err := sf.банк.SetCountDown(времОжидПлат); err != nil {
+			if err := sf.банк.ОбратВремяУст(времОжидПлат); err != nil {
 				log.Printf("WARN Base.checkBankForce(): при установке времени ожидания платного ускорения апгрейда банка(%v)\n\terr=%v\n", времОжидПлат, err)
 			}
 			sf.банк.РежимТекущ().Уст("upgrade")
@@ -747,7 +747,7 @@ func (sf *База) checkBankForce() {
 			}
 			sf.банк.РежимТекущ().Уст("upgrade")
 			sf.банк.РежимТекущ().РежимУст("апгрейд")
-			if err := sf.банк.SetCountDown(времОжидБесплат); err != nil {
+			if err := sf.банк.ОбратВремяУст(времОжидБесплат); err != nil {
 				log.Printf("WARN Base.checkBankForce(): при установке времени бесплатного ускорения агрейда банка(%v)\n\terr=%v\n", времОжидБесплат, err)
 			}
 		}
@@ -775,7 +775,7 @@ func (sf *База) шахтаАпгрейдФорсаж() {
 		if isOut && strings.Contains(strOut, `Ускорить за`) {
 			sf.шахта.РежимТекущ().Уст("upgrade")
 			sf.шахта.РежимТекущ().РежимУст("апгрейд")
-			if err := sf.шахта.SetCountDown(времОжидПлат); err != nil {
+			if err := sf.шахта.ОбратВремяУст(времОжидПлат); err != nil {
 				log.Printf("WARN Base.checkMineForce(): при установке времени платного апгрейда шахты(%v)\n\terr=%v\n", времОжидПлат, err)
 			}
 			return
@@ -806,7 +806,7 @@ func (sf *База) шахтаАпгрейдФорсаж() {
 				// log._rintf("ERRO NetBank.checkMineForce(): при обновлении lstBase, err=\n\t%v\n", err)
 				return
 			}
-			if err := sf.шахта.SetCountDown(времОжидБесплат); err != nil {
+			if err := sf.шахта.ОбратВремяУст(времОжидБесплат); err != nil {
 				log.Printf("WARN Base.checkMineForce(): при установке времени апгрейда шахты(%v)\n\terr=%v\n", времОжидБесплат, err)
 			}
 			// sound.MineForce()
@@ -827,8 +827,8 @@ func (sf *База) проверитьПолигонУсиление() {
 		isOut   bool
 		lstBase = sf.СписПолучить()
 	)
-	countTime := sf.полигон.ВремяОпрос().Получ()
-	if countTime > 3 {
+	countTime := sf.полигон.ВремяОпрос().ПолучМилСек()
+	if countTime > 3_000 {
 		return
 	}
 	{ // Проверка на платное ускорение апгрейда
@@ -852,7 +852,7 @@ func (sf *База) проверитьПолигонУсиление() {
 			// }
 			sf.полигон.РежимТекущ().Уст("upgrade")
 			sf.полигон.РежимТекущ().РежимУст("апгрейд")
-			if err := sf.полигон.SetCountDown(времОжидПлат); err != nil {
+			if err := sf.полигон.ОбратВремяУст(времОжидПлат); err != nil {
 				log.Printf("WARN Base.checkPolygonForce(): при установке платного времени апгрейда полигона(%v)\n\terr=%v\n", времОжидПлат, err)
 			}
 			return
@@ -887,7 +887,7 @@ func (sf *База) проверитьПолигонУсиление() {
 			sf.полигон.РежимТекущ().Уст("upgrade")
 			sf.полигон.РежимТекущ().РежимУст("апгрейд")
 			// Установить время ожидания для обновления
-			if err := sf.полигон.SetCountDown(времОжидБесплат); err != nil {
+			if err := sf.полигон.ОбратВремяУст(времОжидБесплат); err != nil {
 				log.Printf("WARN Base.checkPolygonForce(): при установке времени бесплатного апгрейда полигона(%v)\n\terr=%v\n", времОжидБесплат, err)
 			}
 			// log._rintf("INFO NetBank.checkPolygonForce(): ускорено строительство полигона\n")

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

@@ -6,6 +6,7 @@ import (
 	"strings"
 	"time"
 
+	"wartank/pkg/alias"
 	"wartank/pkg/components/section"
 	"wartank/pkg/types"
 	"wartank/server/serv_bots/warbot/angar/base/market/marketnet"
@@ -24,7 +25,7 @@ type Рынок struct {
 
 // НовРынок -- возвращает новый рынок
 func НовРынок(база types.ИБаза) (*Рынок, error) {
-	section, err := section.NewSection(база.Бот(), "Рынок", `<title>Рынок</title>`)
+	section, err := section.НовСекция(база.Бот(), "Рынок", `<title>Рынок</title>`)
 	if err != nil {
 		return nil, fmt.Errorf("NewMarket(): in create *Section, err=\n\t%w", err)
 	}
@@ -53,13 +54,12 @@ func (сам *Рынок) пуск() {
 	for {
 		select {
 		case <-сам.бот.Кнт().Done():
-			сам.ВремяОпрос().Стоп()
 			return
 		case <-сам.ВремяОпрос().КаналСиг():
-			log.Printf("Market.run(): timeCount=%v\n", сам.ВремяОпрос().Получ())
+			log.Printf("Market.run(): timeCount=%v\n", сам.ВремяОпрос().ПолучМилСек())
 			_ = сам.купитьЗолото()
 			// Если золото не куплено -- обновить время ожидания
-			сам.SetCountDown(120)
+			сам.Секция.ОбратВремяУст(120 * 1_000)
 		}
 		сам.проверОжидание()
 		for сам.купитьЗолото() {
@@ -120,7 +120,7 @@ func (сам *Рынок) проверОжидание() {
 		}
 		lstTime := strings.Split(strOut, `Минимальная цена через `)
 		strTime := lstTime[1]
-		if err := сам.ParseCountDown(strTime); err != nil {
+		if err := сам.ParseCountDown(alias.Время(strTime)); err != nil {
 			// log._rintf("ERRO Market.checkTime(): при установке времени ожидания рынка(%v)\n\terr=%v\n", strTime, err)
 			return // Возможно минимальная цена
 		}

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

@@ -7,6 +7,7 @@ import (
 	"strings"
 	"time"
 
+	"wartank/pkg/alias"
 	"wartank/pkg/components/section"
 	"wartank/pkg/types"
 	"wartank/server/serv_bots/warbot/angar/base/mine/minenet"
@@ -35,7 +36,7 @@ type Шахта struct {
 
 // НовШахта -- возвращает новый *Mine
 func НовШахта(база types.ИБаза) (*Шахта, error) {
-	секция, ош := section.NewSection(база.Бот(), "Шахта", `<span class="green2">Руда</span><br/>`)
+	секция, ош := section.НовСекция(база.Бот(), "Шахта", `<span class="green2">Руда</span><br/>`)
 	if ош != nil {
 		return nil, fmt.Errorf("НовШахта(): in create *Section, err=\n\t%w", ош)
 	}
@@ -92,7 +93,6 @@ func (сам *Шахта) пуск() {
 	for {
 		select {
 		case <-сам.бот.Кнт().Done():
-			сам.ВремяОпрос().Стоп()
 			return
 		case <-сам.ВремяОпрос().КаналСиг():
 		default:
@@ -159,8 +159,8 @@ func (сам *Шахта) количествоПолучить() {
 	// <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 {
+	сам.продуктВремя = strTime
+	if err := сам.ParseCountDown(alias.Время(strTime)); err != nil {
 		log.Printf("Шахта.количествоПолучить(): при установке времени производства(%v), err=\n\t%v\n", strTime, err)
 	}
 }
@@ -487,7 +487,7 @@ func (сам *Шахта) рудаСделать() {
 		// log._rintf("ERRO Шахта.сделатьРуду(): при обновлении lstMine, err=\n\t%v\n", err)
 		return
 	}
-	if err := сам.ParseCountDown(strTime); err != nil {
+	if err := сам.ParseCountDown(alias.Время(strTime)); err != nil {
 		log.Printf("ERRO Шахта.сделатьРуду(): при установке времени ожидания добычи руды(%v)\n\terr=%v\n", strTime, err)
 	}
 	lstNum := strings.Split(strNum, `Кол-во: <span class="green2">`)
@@ -547,7 +547,7 @@ func (сам *Шахта) железоСделать() {
 		// log._rintf("ERRO MineNet.makeFerrum(): при обновлении lstMine, err=\n\t%v\n", err)
 		return
 	}
-	if err := сам.ParseCountDown(strTime); err != nil {
+	if err := сам.ParseCountDown(alias.Время(strTime)); err != nil {
 		log.Printf("ERRO Mine.makeFerrum(): при установке времени производства железа(%v)\n\terr=%v\n", strTime, err)
 	}
 	lstNum := strings.Split(strNum, `Кол-во: <span class="green2">`)
@@ -607,7 +607,7 @@ func (сам *Шахта) стальСделать() {
 		// log._rintf("ERRO MineNet.makeSteel(): при обновлении lstMine, err=\n\t%v\n", err)
 		return
 	}
-	if err := сам.ParseCountDown(strTime); err != nil {
+	if err := сам.ParseCountDown(alias.Время(strTime)); err != nil {
 		log.Printf("ERRO Mine.makeSteel(): при установке времени производства железа(%v)\n\terr=%v\n", strTime, err)
 	}
 	lstNum := strings.Split(strNum, `Кол-во: <span class="green2">`)
@@ -667,7 +667,7 @@ func (сам *Шахта) свинецСделать() {
 		// log._rintf("ERRO Шахта.сделатьСвинец(): при обновлении lstMine, err=\n\t%v\n", err)
 		return
 	}
-	if err := сам.ParseCountDown(strTime); err != nil {
+	if err := сам.ParseCountDown(alias.Время(strTime)); err != nil {
 		log.Printf("ERRO Шахта.сделатьСвинец(): при установке времени производства железа(%v)\n\terr=%v\n", strTime, err)
 	}
 	lstNum := strings.Split(strNum, `Кол-во: <span class="green2">`)

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

@@ -7,6 +7,7 @@ import (
 	"strings"
 	"time"
 
+	"wartank/pkg/alias"
 	"wartank/pkg/components/section"
 	"wartank/pkg/types"
 	"wartank/server/serv_bots/warbot/angar/base/polygon/polygonnet"
@@ -32,7 +33,7 @@ type Полигон struct {
 
 // НовПолигон -- возвращает новый *Polygon
 func НовПолигон(base types.ИБаза) (*Полигон, error) {
-	секция, ош := section.NewSection(base.Бот(), "Полигон", `<title>Полигон</title>`)
+	секция, ош := section.НовСекция(base.Бот(), "Полигон", `<title>Полигон</title>`)
 	if ош != nil {
 		return nil, fmt.Errorf("NewPolygon(): in create *Section, err=\n\t%w", ош)
 	}
@@ -56,11 +57,10 @@ func (sf *Полигон) Пуск() error {
 
 // выполняет опрос полигона базы.
 func (сам *Полигон) пуск() {
-	сам.SetCountDown(2)
+	сам.ОбратВремяУст(2_000)
 	for {
 		select {
 		case <-сам.бот.Кнт().Done():
-			сам.ВремяОпрос().Стоп()
 			return
 		case <-сам.ВремяОпрос().КаналСиг():
 		default:
@@ -103,7 +103,7 @@ func (сам *Полигон) проверитьУскорение() {
 		}
 		{ // Платное ускорение
 			if strings.Contains(strOut, `Ускорить за`) {
-				if err := сам.SetCountDown(времОжидПлат); err != nil {
+				if err := сам.ОбратВремяУст(времОжидПлат); err != nil {
 					log.Printf("WARN Base.checkArsenalForce(): при установке платного времени ускорения апгрейда арсенала(%v)\n\terr=%v\n", времОжидПлат, err)
 				}
 				сам.РежимТекущ().Уст("upgrade")
@@ -144,7 +144,7 @@ func (сам *Полигон) проверитьУскорение() {
 		}
 		сам.РежимТекущ().Уст("upgrade")
 		сам.РежимТекущ().РежимУст("апгрейд")
-		if err := сам.SetCountDown(времОжидБесплат); err != nil {
+		if err := сам.ОбратВремяУст(времОжидБесплат); err != nil {
 			log.Printf("WARN Base.checkArsenalForce(): при установке бесплатного времени ускорения апгрейда арсенала(%v)\n\terr=%v\n", времОжидБесплат, err)
 		}
 	}
@@ -228,7 +228,7 @@ func (сам *Полигон) времяОбнов() {
 	)
 	defer func() {
 		if !isSet {
-			сам.SetCountDown(5)
+			сам.ОбратВремяУст(5_000)
 		}
 	}()
 	for _, lastTime := range lstPolygon {
@@ -245,7 +245,7 @@ func (сам *Полигон) времяОбнов() {
 	strLastTime = lstTime[1]
 	lstTime = strings.Split(strLastTime, `</span>`)
 	strLastTime = lstTime[0]
-	if err := сам.ParseCountDown(strLastTime); err != nil {
+	if err := сам.ParseCountDown(alias.Время(strLastTime)); err != nil {
 		// log._rintf("ERRO Polygon.updateTime(): при установке времени ожидания полигона(%v)\n\terr=%v\n", strLastTime, err)
 		return
 	}
@@ -301,7 +301,7 @@ func (сам *Полигон) усилениеПровер() {
 func (сам *Полигон) усилениеДобавить() {
 	if err := сам.сеть.UpdateLst(); err != nil {
 		// log._rintf("Polygon.checkPolygon(): при принудительном обновлении lstPlygon, mode=%s\terr=\n\t%v\n", sf.ModeCurrent().Get(), err)
-		сам.SetCountDown(5)
+		сам.ОбратВремяУст(5_000)
 		return
 	}
 	lstPoligon := сам.СписПолучить()

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

@@ -27,7 +27,7 @@ type Сражение struct {
 
 // НовСражение -- возвращает новый *Battle
 func НовСражение(бот types.ИБот) (*Сражение, error) {
-	секция, ош := section.NewSection(бот, "Группа сражения", `<span>до начала `)
+	секция, ош := section.НовСекция(бот, "Группа сражения", `<span>до начала `)
 	if ош != nil {
 		return nil, fmt.Errorf("НовСражение(): in create *Section, err=\n\t%w", ош)
 	}

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

@@ -22,7 +22,7 @@ type СражениеРегистрация struct {
 
 // НовСражениеРегистрация -- возвращает новый ожидатель битвы
 func НовСражениеРегистрация(бот types.ИБот) (*СражениеРегистрация, error) {
-	секция, ош := section.NewSection(бот, "Сражение", `<title>Сражения</title>`)
+	секция, ош := section.НовСекция(бот, "Сражение", `<title>Сражения</title>`)
 	if ош != nil {
 		return nil, fmt.Errorf("НовСражениеРегистрация(): in create ISection, err=\n\t%w", ош)
 	}

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

@@ -7,6 +7,7 @@ import (
 	"strings"
 	"time"
 
+	"wartank/pkg/alias"
 	"wartank/pkg/components/section"
 	"wartank/pkg/components/sectionnet"
 	"wartank/pkg/types"
@@ -21,7 +22,7 @@ type СражениеОжидание struct {
 
 // НовСражениеОжидание -- возвращает новый ожидатель битвы
 func НовСражениеОжидание(bot types.ИБот) (*СражениеОжидание, error) {
-	section, err := section.NewSection(bot, "Ожидание сражения", `<title>Сражения</title>`)
+	section, err := section.НовСекция(bot, "Ожидание сражения", `<title>Сражения</title>`)
 	if err != nil {
 		return nil, fmt.Errorf("NewBattleWait(): in create ISection, err=\n\t%w", err)
 	}
@@ -105,7 +106,7 @@ func (сам *СражениеОжидание) ждать() string {
 	strTime := lstTime[1]
 	lstTime = strings.Split(strTime, ` (`)
 	strTime = lstTime[0]
-	if err := сам.ParseCountDown(strTime); err != nil { // Возможно уже всё
+	if err := сам.Секция.ParseCountDown(alias.Время(strTime)); err != nil { // Возможно уже всё
 		// log._rintf("WARN BattleWait.Wait(): при установке времени ожидания сражения(%v)\n\terr=%v\n", strTime, err)
 		return ""
 	}

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

@@ -29,7 +29,7 @@ type СражениеИсполнитель struct {
 
 // НовСражениеДействие -- возвращает новый исполнитель битвы
 func НовСражениеИсполнитель(bot types.ИБот) (*СражениеИсполнитель, error) {
-	section, err := section.NewSection(bot, "Ход сражения", `<title>Сражения</title>`)
+	section, err := section.НовСекция(bot, "Ход сражения", `<title>Сражения</title>`)
 	if err != nil {
 		return nil, fmt.Errorf("NewBattleWorker(): in create *Section, err=\n\t%w", err)
 	}

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

@@ -35,7 +35,7 @@ type СражениеДействие struct {
 
 // НовСражениеДействие -- возвращает новый *BattleOn
 func НовСражениеДействие(бот types.ИБот) (*СражениеДействие, error) {
-	секция, ош := section.NewSection(бот, "Исполнитель сражения", `<title>Сражения</title>`)
+	секция, ош := section.НовСекция(бот, "Исполнитель сражения", `<title>Сражения</title>`)
 	if ош != nil {
 		return nil, fmt.Errorf("НовСражениеДействие(): in create ISection, err=\n\t%w", ош)
 	}

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

@@ -9,6 +9,7 @@ import (
 
 	"github.com/sirupsen/logrus"
 
+	"wartank/pkg/alias"
 	"wartank/pkg/components/section"
 	"wartank/pkg/types"
 	"wartank/server/serv_bots/warbot/angar/convoy/convoynet"
@@ -29,7 +30,7 @@ type Конвой struct {
 
 // НовКонвой -- возвращает новый *Convoy
 func НовКонвой(bot types.ИБот) (*Конвой, error) {
-	section, err := section.NewSection(bot, "Конвой", `<title>Конвой</title>`)
+	section, err := section.НовСекция(bot, "Конвой", `<title>Конвой</title>`)
 	if err != nil {
 		return nil, fmt.Errorf("НовКонвой(): in create ISection, err=\n\t%w", err)
 	}
@@ -139,7 +140,7 @@ func (sf *Конвой) обновитьВремя() {
 	// Время подходит надо обновляться
 	if err := sf.net.UpdateLst(); err != nil {
 		logrus.WithError(err).Error("Конвой.обновитьВремя(): при выполнении GET-команды обновления")
-		sf.SetCountDown(20)
+		sf.ОбратВремяУст(20_000)
 		return
 	}
 	// Найти строку с упоминанием оставшегося времени конвоя
@@ -177,25 +178,25 @@ func (sf *Конвой) обновитьВремя() {
 		// Ждём окончания ожидания конвоя
 		lstTime := strings.Split(strLastTime, `До следующего конвоя: `)
 		strLastTime = lstTime[1]
-		if err := sf.ParseCountDown(strLastTime); err != nil {
+		if err := sf.ParseCountDown(alias.Время(strLastTime)); err != nil {
 			// log._rintf("WARN Конвой.обновитьВремя(): при установке времени ожидания конвоя(%v)\n\terr=%v\n", strLastTime, err)
-			sf.SetCountDown(10)
+			sf.ОбратВремяУст(10_000)
 		}
 	case isMask: // Если маскировка между конвоями
 		// Ждём окончания ожидания конвоя
 		lstTime := strings.Split(strLastTime, `Полная маскировка через `)
 		strLastTime = lstTime[1]
-		if err := sf.ParseCountDown(strLastTime); err != nil {
+		if err := sf.ParseCountDown(alias.Время(strLastTime)); err != nil {
 			// log._rintf("ERRO BКонвой.обновитьВремя(): при установке времени банка для 1го режима(%v)\n\terr=%v\n", strLastTime, err)
-			sf.SetCountDown(10)
+			sf.ОбратВремяУст(10_000)
 		}
 	}
 }
 
 func (сам *Конвой) найтиВбой() string {
 	var (
-		strOut    = ""
-		isFind    bool
+		strOut = ""
+		isFind bool
 	)
 	lstConvoy, err := сам.net.Клиент().Get("https://wartank.ru/convoy")
 	if err != nil {
@@ -288,7 +289,7 @@ func (сам *Конвой) атакаНачать() {
 		return
 	}
 	сам.начатьРазведку()
-	if err := сам.SetCountDown(1); err != nil {
+	if err := сам.ОбратВремяУст(1_000); err != nil {
 		panic(fmt.Errorf("Конвой.атакаНачать(): при установке CountDown, err=\n\t%w", err))
 	}
 }
@@ -297,12 +298,12 @@ func (сам *Конвой) атакаНачать() {
 func (sf *Конвой) начатьРазведку() {
 	// Вырезать ссылку на атаку
 	strOut := ""
-	isFind:=false
+	isFind := false
 	lstConvoy := sf.СписПолучить()
 	// <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
+			isFind = true
 			break
 		}
 	}
@@ -313,16 +314,16 @@ func (sf *Конвой) начатьРазведку() {
 	_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
+	link := "https://wartank.ru/" + _link
 	{ // Выполнить атаку
 		var err error
 		lstConvoy, err = sf.net.Клиент().Get(link)
 		if err != nil {
-			log.Printf("Конвой.attack(): in get page find attack, err=\n\t%v\n",err)
+			log.Printf("Конвой.attack(): in get page find attack, err=\n\t%v\n", err)
 			return
 		}
 		if err = sf.СтрОбновить(lstConvoy); err != nil {
-			log.Printf("Конвой.attack(): при обновлении lstConvoy, err=\n\t%v\n",err)
+			log.Printf("Конвой.attack(): при обновлении lstConvoy, err=\n\t%v\n", err)
 			return
 		}
 	}

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

@@ -2,12 +2,13 @@ package divwar
 
 import (
 	"fmt"
-	// "log"
+	"log"
 	"net/http"
 	"strings"
 	"sync"
 	"time"
 
+	"wartank/pkg/alias"
 	"wartank/pkg/components/section"
 	"wartank/pkg/types"
 	"wartank/server/serv_bots/warbot/angar/division/divwar/divwarnet"
@@ -58,7 +59,7 @@ func NewDivWar(bot types.ИБот) (*DivWar, error) {
 	// sf.shotTimeFull.Set(8000) // 8000 msec
 	var err error
 	{ // ISection
-		sf.Секция, err = section.NewSection(bot, "Битва дивизий", `<span>до начала `)
+		sf.Секция, err = section.НовСекция(bot, "Битва дивизий", `<span>до начала `)
 		if err != nil {
 			return nil, fmt.Errorf("NewDivWar(): in create *Section, err=\n\t%w", err)
 		}
@@ -75,16 +76,15 @@ func NewDivWar(bot types.ИБот) (*DivWar, error) {
 }
 
 func (sf *DivWar) reservTick() {
-	defer sf.ВремяОпрос().Стоп()
 	for {
 		select {
 		case <-sf.bot.Кнт().Done():
 			return
 		default:
-			ct0 := sf.ВремяОпрос().Получ()
+			ct0 := sf.ВремяОпрос().ПолучМилСек()
 			time.Sleep(time.Second * 7)
-			ct1 := sf.ВремяОпрос().Получ()
-			if ct1 != ct0 {
+			ct1 := sf.ВремяОпрос().ПолучМилСек()
+			if ct1.Сек() != ct0.Сек() {
 				continue
 			}
 			if sf.divon != nil {
@@ -101,7 +101,6 @@ func (sf *DivWar) run() {
 	for {
 		select {
 		case <-sf.bot.Кнт().Done():
-			sf.ВремяОпрос().Стоп()
 			return
 		case <-sf.ВремяОпрос().КаналСиг(): // Время обновить данные по сражению
 			sf.findTimeCount()
@@ -152,17 +151,17 @@ func (sf *DivWar) findTimeCount() {
 	strTime := lstTime[1]
 	lstTime = strings.Split(strTime, `</span>`)
 	strTime = lstTime[0]
-	if err := sf.ParseCountDown(strTime); err != nil {
+	if err := sf.ParseCountDown(alias.Время(strTime)); err != nil {
 		// log._rintf("WARN DivWar.findTimeCount(): при установке времени ожидания битвы дивизий(%v)\n\terr=%v\n", strTime, err)
 		return
 	}
 }
 
 // При необходимости поднимает взвод в атаку, вызывается только если обнаружено приглашение (+)
-func (sf *DivWar) upDivWar() {
+func (сам *DivWar) upDivWar() {
 	var (
 		strOut    string
-		lstDivWar = sf.СписПолучить()
+		lstDivWar = сам.СписПолучить()
 		isFind    bool
 	)
 	for _, strOut = range lstDivWar {
@@ -183,13 +182,13 @@ func (sf *DivWar) upDivWar() {
 	linkUp := lstUp[1]
 	lstUp = strings.Split(linkUp, `"><span><span>Взвод, подъем! В атаку!</span></span></a>`)
 	linkUp = "https://wartank.ru/" + lstUp[0]
-	lstDivWar, err := sf.net.Get(linkUp)
+	lstDivWar, err := сам.net.Get(linkUp)
 	if err != nil {
 		// log._rintf("ERRO DivWar.upDivWar(): при выполнении GET-команды на подъём в атаку, err=\n\t%v\n", err)
 		return
 	}
-	if err = sf.СтрОбновить(lstDivWar); err != nil {
-		// log._rintf("ERRO DivWar.upDivWar(): при обновлении lstDivWar, err=\n\t%v\n", err)
+	if err = сам.СтрОбновить(lstDivWar); err != nil {
+		log.Printf("DivWar.upDivWar(): при обновлении lstDivWar, err=\n\t%v\n", err)
 	}
 	// log._rintf("INFO DivWar.upDivWar(): регистрация прошла успешно\n")
 }
@@ -199,7 +198,7 @@ func (sf *DivWar) DivWar() {
 	defer func() {
 		sf.divon = nil
 		sf.block.Unlock()
-		if err := sf.SetCountDown(1); err != nil {
+		if err := sf.Секция.ОбратВремяУст(1_000); err != nil {
 			panic(fmt.Errorf("DivWar.DivWar(): при установке CountDown, err=\n\t%w", err))
 		}
 		// log.Printf("INFO DivWar.DivWar(): сражение завершено\n")

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

@@ -52,7 +52,7 @@ func NewDivWarOn(bot types.ИБот) (*DivWarOn, error) {
 	}
 	var err error
 	{ // ISection (ожидание)
-		sf.Секция, err = section.NewSection(bot, "Ожидание битвы дивизий", `<title>Сражения</title>`)
+		sf.Секция, err = section.НовСекция(bot, "Ожидание битвы дивизий", `<title>Сражения</title>`)
 		if err != nil {
 			return nil, fmt.Errorf("NewDivWarOn(): in create *Section, err=\n\t%w", err)
 		}

server/serv_bots/warbot/angar/masters/bat_masters.go

@@ -6,6 +6,7 @@ import (
 	"strings"
 	"time"
 
+	"wartank/pkg/alias"
 	"wartank/pkg/components/section"
 	"wartank/pkg/types"
 	"wartank/server/serv_bots/warbot/angar/masters/batmasnet"
@@ -40,7 +41,7 @@ func НовБитваМастеров(бот types.ИБот) (*БитваМас
 func (sf *БитваМастеров) Run() error {
 	var err error
 	{ // ISection (ожидание)
-		sf.Секция, err = section.NewSection(sf.бот, "Битва мастеров", `/> Битва мастеров <`)
+		sf.Секция, err = section.НовСекция(sf.бот, "Битва мастеров", `/> Битва мастеров <`)
 		if err != nil {
 			return fmt.Errorf("BatMas.Run(): in create *Section, err=\n\t%w", err)
 		}
@@ -57,7 +58,6 @@ func (sf *БитваМастеров) Run() error {
 			time.Sleep(time.Second * 10)
 			select {
 			case <-sf.бот.Кнт().Done():
-				sf.ВремяОпрос().Стоп()
 				return
 			case <-sf.ВремяОпрос().КаналСиг():
 				if !sf.goBatMas() { // Проверка на начало сражения
@@ -77,10 +77,10 @@ func (sf *БитваМастеров) goBatMas() bool {
 	if !sf.upBattle() {
 		return false
 	}
-	countTime := sf.ВремяОпрос().Получ()
-	countTime -= 5
-	if countTime > 25 {
-		if err := sf.SetCountDown(countTime); err != nil {
+	countTime := sf.ВремяОпрос().ПолучМилСек()
+	countTime -= 5_000
+	if countTime > 25_000 {
+		if err := sf.ОбратВремяУст(countTime); err != nil {
 			log.Printf("ERRO BatMas.goBatMas(): при установке времени ожидания битвы мастеров(%v)\n\terr=%v\n", countTime, err)
 		}
 		return false
@@ -93,7 +93,7 @@ func (sf *БитваМастеров) goBatMas() bool {
 		return true
 	}
 	// Время ожидания вышло, надо начать атаку
-	if err := sf.SetCountDown(0); err != nil {
+	if err := sf.ОбратВремяУст(0); err != nil {
 		log.Printf("ERRO BatMas.goBatMas(): при установке времени ожидания битвы мастеров(0)\n\terr=%v\n", err)
 	}
 	return false
@@ -119,7 +119,7 @@ func (sf *БитваМастеров) findTimeCount() {
 		lstTime = strings.Split(strTime, ` (`)
 		strTime = lstTime[0]
 
-		if err := sf.ParseCountDown(strTime); err != nil {
+		if err := sf.ParseCountDown(alias.Время(strTime)); err != nil {
 			log.Printf("WARN BatMas.findTimeCount(): при установке времени ожидания битвы мастеров(%v)\n\terr=%v\n", strTime, err)
 		}
 	}

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

@@ -24,7 +24,7 @@ type Миссии struct {
 
 // НовМиссии -- возвращает новый *Миссии
 func НовМиссии(бот types.ИБот) (*Миссии, error) {
-	section, err := section.NewSection(бот, "Миссии", `<title>Миссии</title>`)
+	section, err := section.НовСекция(бот, "Миссии", `<title>Миссии</title>`)
 	if err != nil {
 		return nil, fmt.Errorf("НовМиссии(): in create *Section, err=\n\t%w", err)
 	}