d03 Исправления под счётчик времени

pkg/components/kernel/slog/slog.go

@@ -2,7 +2,6 @@ package slog
 
 import (
 	"fmt"
-	"os"
 	"strings"
 	"sync"
 	"time"
@@ -42,25 +41,21 @@ func NewSlog(kern types.IKernel) (*Slog, error) {
 	if kern == nil {
 		return nil, fmt.Errorf("NewSlog(): IKernel is nil")
 	}
-	os.Setenv("BUILD", "test_BUILD")
-	build := os.Getenv("BUILD")
-	if build == "" {
-		return nil, fmt.Errorf("NewSlog(): strBuild is empty")
-	}
 	sf := &Slog{
 		kern:   kern,
 		buf:    strings.Builder{},
 		lt:     slog_term.NewSlogTerm(),
 		isWork: safebool.NewSafeBool(),
+		level:  LevelDebug,
 	}
-	lf, err := slog_file.NewSlogFile(kern, build)
+	lf, err := slog_file.NewSlogFile(kern, "test")
 	if err != nil {
 		return nil, fmt.Errorf("NewSlog(): in create SlogFile, err=\n\t%w", err)
 	}
 	sf.lf = lf
 
 	go sf.close()
-	sf.isWork.Set()
+	sf.isWork.Уст()
 	sf.kern.Wg().Add(strSlog)
 	sf.Infof("NewSlog()\n")
 	return sf, nil
@@ -70,7 +65,7 @@ func NewSlog(kern types.IKernel) (*Slog, error) {
 func (sf *Slog) Debugf(str string, lstVal ...interface{}) {
 	sf.block.Lock()
 	defer sf.block.Unlock()
-	if !sf.isWork.Get() {
+	if !sf.isWork.Получ() {
 		return
 	}
 	sf.printf("DEBUG", str, lstVal...)
@@ -80,7 +75,7 @@ func (sf *Slog) Debugf(str string, lstVal ...interface{}) {
 func (sf *Slog) Infof(str string, lstVal ...interface{}) {
 	sf.block.Lock()
 	defer sf.block.Unlock()
-	if !sf.isWork.Get() {
+	if !sf.isWork.Получ() {
 		return
 	}
 	sf.printf("INFO", str, lstVal...)
@@ -90,7 +85,7 @@ func (sf *Slog) Infof(str string, lstVal ...interface{}) {
 func (sf *Slog) Warnf(str string, lstVal ...interface{}) {
 	sf.block.Lock()
 	defer sf.block.Unlock()
-	if !sf.isWork.Get() {
+	if !sf.isWork.Получ() {
 		return
 	}
 	sf.printf("WARN", str, lstVal...)
@@ -100,7 +95,7 @@ func (sf *Slog) Warnf(str string, lstVal ...interface{}) {
 func (sf *Slog) Errorf(str string, lstVal ...interface{}) {
 	sf.block.Lock()
 	defer sf.block.Unlock()
-	if !sf.isWork.Get() {
+	if !sf.isWork.Получ() {
 		return
 	}
 	sf.printf("ERROR", str, lstVal...)
@@ -135,10 +130,10 @@ func (sf *Slog) printf(pref, str string, lstVal ...interface{}) {
 func (sf *Slog) close() {
 	<-sf.kern.Done()
 	sf.block.Lock()
-	if !sf.isWork.Get() {
+	if !sf.isWork.Получ() {
 		return
 	}
-	sf.isWork.Reset()
+	sf.isWork.Сброс()
 	sf.kern.Wg().Done(strSlog)
 	sf.block.Unlock()
 }

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

@@ -43,7 +43,7 @@ func NewSlogFile(kern types.IKernel, build string) (*SlogFile, error) {
 		isWork:   safebool.NewSafeBool(),
 		chMsg:    make(chan []byte, 10),
 	}
-	sf.isWork.Set()
+	sf.isWork.Уст()
 	_ = os.MkdirAll("./log", 0700)
 	sf.fileName = "./log/" + sf.fileName
 	if err := sf.open(); err != nil {
@@ -68,7 +68,7 @@ func (sf *SlogFile) open() error {
 // Запускает работу в отдельном потоке
 func (sf *SlogFile) run() {
 	defer func() {
-		sf.isWork.Reset()
+		sf.isWork.Сброс()
 		sf.block.Lock()
 		defer sf.block.Unlock()
 		_ = sf.file.Close()
@@ -101,7 +101,7 @@ func (sf *SlogFile) write(msg []byte) error {
 
 // Write -- записывает данные в файл
 func (sf *SlogFile) Write(msg string) {
-	if !sf.isWork.Get() {
+	if !sf.isWork.Получ() {
 		return
 	}
 	sf.block.Lock()

pkg/components/kernel/slog/slog_test.go

@@ -33,7 +33,6 @@ func TestSlog(t *testing.T) {
 // Создание логера
 func (sf *tester) create() {
 	sf.t.Logf("=create=\n")
-	sf.createBad1()
 	sf.createBad2()
 	sf.createGood1()
 }
@@ -69,16 +68,3 @@ func (sf *tester) createBad2() {
 		sf.t.Errorf("createBad2): slog!=nil")
 	}
 }
-
-// Нет строки сборки
-func (sf *tester) createBad1() {
-	sf.t.Logf("=createBad1=\n")
-	slog, err := NewSlog(sf.kern)
-	if err == nil {
-		sf.t.Errorf("createBad1(): in create ISlog, err==nil")
-	}
-	if slog != nil {
-		sf.t.Errorf("createBad1(): slog!=nil")
-	}
-	// os.RemoveAll(slog.)
-}

pkg/components/kernel/wgname/wgname.go

@@ -23,7 +23,7 @@ func NewWgName() *WgName {
 		chEnd:    make(chan int, 1),
 		isWork:   safebool.NewSafeBool(),
 	}
-	sf.isWork.Set()
+	sf.isWork.Уст()
 	return sf
 }
 
@@ -48,11 +48,11 @@ func (sf *WgName) Done(name string) error {
 		return fmt.Errorf("WgName.Done(): name %q not exists", name)
 	}
 	delete(sf.dictName, name)
-	if !sf.isWork.Get() {
+	if !sf.isWork.Получ() {
 		return nil
 	}
 	if len(sf.dictName) == 0 {
-		sf.isWork.Reset()
+		sf.isWork.Сброс()
 		close(sf.chEnd)
 	}
 	return nil

pkg/components/safebool/safebool.go

@@ -17,22 +17,22 @@ func NewSafeBool() *SafeBool {
 	return &SafeBool{}
 }
 
-// Get -- возвращает хранимое значение булевого признака
-func (sf *SafeBool) Get() bool {
+// Получ -- возвращает хранимое значение булевого признака
+func (sf *SafeBool) Получ() bool {
 	sf.block.RLock()
 	defer sf.block.RUnlock()
 	return sf.val
 }
 
-// Set -- устанавливает хранимое значение булевого признака
-func (sf *SafeBool) Set() {
+// Уст -- устанавливает хранимое значение булевого признака
+func (sf *SafeBool) Уст() {
 	sf.block.Lock()
 	defer sf.block.Unlock()
 	sf.val = true
 }
 
-// Reset -- сбарсывает хранимое значение булевого признака
-func (sf *SafeBool) Reset() {
+// Сброс -- сбарсывает хранимое значение булевого признака
+func (sf *SafeBool) Сброс() {
 	sf.block.Lock()
 	defer sf.block.Unlock()
 	sf.val = false

pkg/components/safebool/safebool_test.go

@@ -23,12 +23,12 @@ func TestSafeBool(t *testing.T) {
 // Присовение и сброс признака
 func (sf *tester) set() {
 	sf.t.Logf("=set=\n")
-	sf.sb.Set()
-	if isReset := sf.sb.Get(); !isReset {
+	sf.sb.Уст()
+	if isReset := sf.sb.Получ(); !isReset {
 		sf.t.Errorf("create(): isReset==true\n")
 	}
-	sf.sb.Reset()
-	if isSet := sf.sb.Get(); isSet {
+	sf.sb.Сброс()
+	if isSet := sf.sb.Получ(); isSet {
 		sf.t.Errorf("create(): isSet==true\n")
 	}
 }
@@ -40,7 +40,7 @@ func (sf *tester) create() {
 	if sf.sb == nil {
 		sf.t.Errorf("create(): safeBool==nil\n")
 	}
-	if isSet := sf.sb.Get(); isSet {
+	if isSet := sf.sb.Получ(); isSet {
 		sf.t.Errorf("create(): isSet==true\n")
 	}
 }

pkg/components/safeint/safeint.go

@@ -24,8 +24,8 @@ func (sf *SafeInt) Get() int {
 	return sf.val
 }
 
-// Set -- устанавливает хранимое значение
-func (sf *SafeInt) Set(val int) {
+// Уст -- устанавливает хранимое значение
+func (sf *SafeInt) Уст(val int) {
 	sf.block.Lock()
 	defer sf.block.Unlock()
 	sf.val = val

pkg/components/safeint/safeint_test.go

@@ -25,7 +25,7 @@ func TestSafeInt(t *testing.T) {
 // Установка значения
 func (sf *tester) set() {
 	sf.t.Logf("=set=\n")
-	sf.si.Set(-8)
+	sf.si.Уст(-8)
 	if val := sf.si.Get(); val != -8 {
 		sf.t.Errorf("create(): val(%d)!=-8\n", val)
 	}

pkg/components/section/down_time/down_time.go

@@ -16,165 +16,172 @@ import (
 )
 
 const (
-	sleepInterval = time.Millisecond * 100 // Малый интервал сна в 100 мсек
+	спатьИнтервал = time.Millisecond * 100 // Малый интервал сна в 100 мсек
 )
 
-// DownTime -- счётчик обратного времени для игровой зоны (анга, база, битва и т.п.)
-type DownTime struct {
-	zone   types.ИСцена
-	val    *safeint.SafeInt     // Фактическое значение счётчика
-	parser *parsetime.ParseTime // Парсер значения
+// ВремОбрат -- счётчик обратного времени для игровой зоны (анга, база, битва и т.п.)
+type ВремОбрат struct {
+	сцена types.ИСцена
 
-	chTick     chan int           // Канал секундных интервалов сна (для отображения)
-	chCall     chan int           // Канал для отправки сигналов (для верхнего уровня)
-	isWork     *safebool.SafeBool // Признак работы
-	timeTarget *safeint.SafeInt   // Целевое время срабатывания
-	ctx        context.Context    // Контекст для счётчика времени
-	fnCancel   func()             // Функция отмены контекста для счётчика времени
+	парсер *parsetime.ParseTime // Парсер значения
 
-	block sync.RWMutex
+	времяЗнач    *safeint.SafeInt   // Фактическое значение счётчика
+	времПорог    *safeint.SafeInt   // Целевое время срабатывания
+	еслиРаботает *safebool.SafeBool // Признак работы
+
+	канТик   chan int // Канал секундных интервалов сна (для отображения)
+	канВызов chan int // Канал для отправки сигналов (для верхнего уровня)
+
+	кнт      context.Context // Контекст для счётчика времени
+	фнОтмена func()          // Функция отмены контекста для счётчика времени
+
+	блок sync.RWMutex
 }
 
-// NewCountTime -- возвращает новый *CountTime
-func NewCountTime(zone types.ИСцена, val int) *DownTime {
-	if zone == nil {
-		panic("NewCountTime(): IZone == nil")
+// НовВремОбрат -- возвращает новый *CountTime
+func НовВремОбрат(сцена types.ИСцена, знач int) *ВремОбрат {
+	if сцена == nil {
+		panic("НовВремОбрат(): ИСцена == nil")
 	}
-	ctx, fnCancel := context.WithCancel(zone.Кнт())
-	sf := &DownTime{
-		zone:       zone,
-		val:        safeint.NewSafeInt(),
-		chTick:     make(chan int, 3),
-		chCall:     make(chan int, 2),
-		isWork:     safebool.NewSafeBool(),
-		parser:     parsetime.NewParseTime(),
-		timeTarget: safeint.NewSafeInt(),
-		ctx:        ctx,
-		fnCancel:   fnCancel,
+	кнт, фнОтмена := context.WithCancel(сцена.Кнт())
+	сам := &ВремОбрат{
+		сцена:        сцена,
+		времяЗнач:    safeint.NewSafeInt(),
+		канТик:       make(chan int, 5),
+		канВызов:     make(chan int, 2),
+		еслиРаботает: safebool.NewSafeBool(),
+		парсер:       parsetime.NewParseTime(),
+		времПорог:    safeint.NewSafeInt(),
+		кнт:          кнт,
+		фнОтмена:     фнОтмена,
 	}
-	val = int(time.Now().UTC().Unix()) + val
-	sf.timeTarget.Set(val)
-	sf.isWork.Set()
-	go sf.makeTick()
-	go sf.run()
-	return sf
+	знач = int(time.Now().UTC().Unix()) + знач
+	сам.времПорог.Уст(знач)
+	сам.еслиРаботает.Уст()
+	go сам.сделатьТик()
+	go сам.пуск()
+	go сам.закрыть()
+	return сам
 }
 
 // Запускает тикер для секундных интервалов
-func (sf *DownTime) makeTick() {
-	defer func() {
-		if !sf.isWork.Get() {
-			return
-		}
-		sf.fnCancel()
-		sf.isWork.Reset()
-		close(sf.chTick)
-		// log._rintf("CountTime.makeTick(): работа завершена")
-	}()
-	countSleep := 0 // Счётчик сна (10 периодов -- 1 секунда)
+func (сам *ВремОбрат) сделатьТик() {
+	спатьСчёт := 0 // Счётчик сна (10 периодов -- 1 секунда)
 	for {
 		select {
-		case <-sf.ctx.Done(): // Отмена контекста бота
+		case <-сам.кнт.Done(): // Отмена контекста бота
 			// log._rintf("CountTime.makeTick(): отмена контекста бота\n")
 			return
 		default:
-			if !sf.isWork.Get() {
+			if !сам.еслиРаботает.Получ() {
+				сам.фнОтмена()
 				return
 			}
 
-			if countSleep >= 10 {
-				sf.chTick <- 1
-				countSleep = 0
+			if спатьСчёт >= 10 {
+				сам.канТик <- 1
+				спатьСчёт = 0
 			}
-			countSleep++
-			time.Sleep(sleepInterval)
+			time.Sleep(спатьИнтервал)
+			спатьСчёт++
 		}
 	}
 }
 
 // Главный цикл обратного отсчёта
-func (sf *DownTime) run() {
-	for range sf.chTick {
+func (sf *ВремОбрат) пуск() {
+	for range sf.канТик {
 		time.Sleep(time.Millisecond * 100)
 		timeNow := time.Now().UTC().Unix()
-		if sf.timeTarget.Get() > int(timeNow) {
+		if sf.времПорог.Get() > int(timeNow) {
 			continue
 		}
-		close(sf.chCall)
-		sf.fnCancel()
+		close(sf.канВызов)
+		sf.фнОтмена()
 		return
 	}
 }
 
 // Стоп -- останавливает работу cчётчика
-func (sf *DownTime) Стоп() {
-	sf.isWork.Reset()
+func (sf *ВремОбрат) Стоп() {
+	sf.еслиРаботает.Сброс()
 }
 
 // Получ -- возвращает число оставшихся сек
-func (sf *DownTime) Получ() int {
-	return sf.val.Get()
+func (sf *ВремОбрат) Получ() int {
+	return sf.времяЗнач.Get()
 }
 
 // устанавливает число оставшихся сек
-func (sf *DownTime) parse(val string) error {
-	sf.block.Lock()
-	defer sf.block.Unlock()
+func (sf *ВремОбрат) parse(val string) error {
+	sf.блок.Lock()
+	defer sf.блок.Unlock()
 	if val == "" {
 		return fmt.Errorf("CountTime.parse(): val is empty")
 	}
-	sf.parser.Parse(val)
-	_val := sf.parser.Hour().Get()*3600 + sf.parser.Min().Get()*60 + sf.parser.Min().Get()
-	sf.val.Set(_val)
-	_val = int(time.Now().UTC().Unix()) + sf.val.Get()
-	sf.timeTarget.Set(_val)
+	sf.парсер.Parse(val)
+	_val := sf.парсер.Hour().Get()*3600 + sf.парсер.Min().Get()*60 + sf.парсер.Min().Get()
+	sf.времяЗнач.Уст(_val)
+	_val = int(time.Now().UTC().Unix()) + sf.времяЗнач.Get()
+	sf.времПорог.Уст(_val)
 	return nil
 }
 
 // устанавливает число оставшихся сек
-func (sf *DownTime) set_val(val int) error {
-	sf.block.Lock()
-	defer sf.block.Unlock()
+func (sf *ВремОбрат) set_val(val int) error {
+	sf.блок.Lock()
+	defer sf.блок.Unlock()
 	if val < 0 {
 		return fmt.Errorf("CountTime.set_val(): val(%v)<0", val)
 	}
-	sf.val.Set(val)
+	sf.времяЗнач.Уст(val)
 	{ // Обновить локальные счётчики
 		if val < 60 {
-			sf.parser.Hour().Reset()
-			sf.parser.Min().Reset()
-			sf.parser.Sec().Set(val)
+			sf.парсер.Hour().Reset()
+			sf.парсер.Min().Reset()
+			sf.парсер.Sec().Set(val)
 			return nil
 		}
 		if 60 < val && val < 3600 {
-			sf.parser.Hour().Reset()
+			sf.парсер.Hour().Reset()
 			iMin := val / 60
-			sf.parser.Min().Set(iMin)
+			sf.парсер.Min().Set(iMin)
 			val -= iMin * 60
-			sf.parser.Sec().Set(val)
+			sf.парсер.Sec().Set(val)
 			return nil
 		}
-		sf.parser.Hour().Set(val / 3600)
-		val -= sf.parser.Hour().Get() * 3600
-		sf.parser.Min().Set(val / 60)
-		val -= sf.parser.Min().Get() * 60
-		sf.parser.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
 }
 
 // Стр -- возвращает строковое представление оставшихся сек
-func (sf *DownTime) Стр() string {
-	sf.block.RLock()
-	defer sf.block.RUnlock()
+func (sf *ВремОбрат) Стр() string {
+	sf.блок.RLock()
+	defer sf.блок.RUnlock()
 	timeNow := time.Now().UTC().Unix()
-	val := sf.timeTarget.Get() - int(timeNow)
-	sf.set_val(val)
-	return sf.parser.String()
+	val := sf.времПорог.Get() - int(timeNow)
+	go sf.set_val(val)
+	return sf.парсер.String()
 }
 
 // КаналСиг -- возвращает канал чтения тиков
-func (sf *DownTime) КаналСиг() <-chan int {
-	return sf.chCall
+func (sf *ВремОбрат) КаналСиг() <-chan int {
+	return sf.канВызов
+}
+
+func (сам *ВремОбрат) закрыть() {
+	<-сам.кнт.Done()
+	сам.блок.Lock()
+	defer сам.блок.Unlock()
+	if !сам.еслиРаботает.Получ() {
+		return
+	}
+	сам.еслиРаботает.Сброс()
+	close(сам.канТик)
 }

pkg/components/section/down_time/down_time_test.go

@@ -4,6 +4,7 @@ import (
 	"testing"
 	"time"
 	"wartank/pkg/components/safebool"
+	"wartank/pkg/mock/mock_zone"
 	"wartank/pkg/mock/mockapp"
 	"wartank/pkg/types"
 )
@@ -17,15 +18,18 @@ type tester struct {
 	t      *testing.T
 	app    *mockapp.MockApp
 	zone   types.ИСцена
-	ct     *DownTime
+	ct     *ВремОбрат
 	err    error
 	isCall *safebool.SafeBool // Признак обратного вызова
 }
 
 // Обратный вызов для счётчика времени
 func (sf *tester) call() {
-	if sf.ct.chCall != nil {
-		<-sf.ct.chCall
+	if sf.ct == nil {
+		return
+	}
+	if sf.ct.канВызов != nil {
+		<-sf.ct.канВызов
 	}
 }
 
@@ -46,9 +50,9 @@ func TestCountTime(t *testing.T) {
 // Оменяет работу таймера
 func (sf *tester) cancel() {
 	sf.t.Logf("=cancel=\n")
-	ct := NewCountTime(sf.zone, 0)
-	for len(ct.chTick) > 0 {
-		<-ct.chTick
+	ct := НовВремОбрат(sf.zone, 0)
+	for len(ct.канТик) > 0 {
+		<-ct.канТик
 	}
 	sf.app.CancelApp()
 	time.Sleep(time.Millisecond * 150)
@@ -56,41 +60,43 @@ func (sf *tester) cancel() {
 
 // Проверяет обработчик тика
 func (sf *tester) checkTick() {
-	ct := NewCountTime(sf.zone, 0)
+	времОбрат := НовВремОбрат(sf.zone, 0)
 	{ // Секундный тик
-		ct.parse("00:00:08")
+		времОбрат.parse("00:00:08")
 		time.Sleep(time.Second * 1)
-		ct.chTick <- 1
+		времОбрат.канТик <- 1
 		time.Sleep(time.Millisecond * 20)
-		if val := ct.Стр(); val != "00:00:08" {
+		if val := времОбрат.Стр(); val != "00:00:08" {
 			sf.t.Errorf("checkTick(): счётчик(%v)!='00:00:08'", val)
 		}
 	}
 	{ // Проверка времени прямо сейчас
-		ct.chTick <- 1
+		времОбрат.канТик <- 1
 		time.Sleep(time.Millisecond * 20)
-		if val := ct.Стр(); val != "00:00:08" {
+		if val := времОбрат.Стр(); val != "00:00:08" {
 			sf.t.Errorf("checkTick(): счётчик(%v)!='00:00:08'", val)
 		}
 	}
 	{ // Проверка обратного вызова прямо сейчас
 		strTime := time.Now().UTC().Format("15:04:05")
-		ct.parse(strTime)
-		if val := ct.Стр(); val != strTime {
+		времОбрат.parse(strTime)
+		if val := времОбрат.Стр(); val != strTime {
 			sf.t.Errorf("checkTick(): счётчик(%v)!=%s", val, strTime)
 		}
-		ct.chTick <- 1
+		времОбрат.канТик <- 1
 		// Выход из функции -- и есть факт обратного вызова
 		sf.call()
 		{ // Проверка отсутствия обратного вызова прямо сейчас
-			ct.parse("00:00:00")
-			ct.chTick <- 1
+			времОбрат.parse("00:00:00")
+			времОбрат.блок.Lock()
+			времОбрат.канТик <- 1
+			времОбрат.блок.Unlock()
 			// Выход из функции -- и есть факт обратного вызова
 			sf.call()
-			if val := ct.Получ(); val != 0 {
+			if val := времОбрат.Получ(); val != 0 {
 				sf.t.Errorf("checkTick(): счётчик(%v)!=0", val)
 			}
-			ct.Стоп()
+			времОбрат.Стоп()
 			sf.app.CancelApp()
 			time.Sleep(time.Millisecond * 50)
 		}
@@ -111,7 +117,7 @@ func (sf *tester) setStrBad1(strBad string) {
 // Устанавливает строковое значение времени
 func (sf *tester) setStr() {
 	go sf.call()
-	ct := NewCountTime(sf.zone, 0)
+	ct := НовВремОбрат(sf.zone, 0)
 	{ // BAD-1 пустая строка
 		if sf.err = ct.parse(""); sf.err == nil {
 			sf.t.Errorf("setStr(): BAD-1 err==nil")
@@ -165,8 +171,8 @@ func (sf *tester) setStr() {
 // Устанавливает число секунд для отсчёта
 func (sf *tester) setInt() {
 	go sf.call()
-	// sf.zone=
-	ct := NewCountTime(sf.zone, 0)
+	sf.zone = mock_zone.НовМокСцена()
+	ct := НовВремОбрат(sf.zone, 0)
 	{ // Bad-1 Отрицательное число
 		if sf.err = ct.set_val(-1); sf.err == nil {
 			sf.t.Errorf("setInt(): BAD-1 err==nil")
@@ -176,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.parser.Hour().Get() != 0 {
-			sf.t.Errorf("setInt(): GOOD-1 hour(%v)!=0", sf.ct.parser.Hour().Get())
+		if ct.парсер.Hour().Get() != 0 {
+			sf.t.Errorf("setInt(): GOOD-1 hour(%v)!=0", sf.ct.парсер.Hour().Get())
 		}
-		if ct.parser.Min().Get() != 0 {
-			sf.t.Errorf("setInt(): GOOD-1 min(%v)!=0", sf.ct.parser.Min().Get())
+		if ct.парсер.Min().Get() != 0 {
+			sf.t.Errorf("setInt(): GOOD-1 min(%v)!=0", sf.ct.парсер.Min().Get())
 		}
-		if ct.parser.Sec().Get() != 8 {
-			sf.t.Errorf("setInt(): GOOD-1 sec(%v)!=8", sf.ct.parser.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)
@@ -193,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.parser.Hour().Get() != 0 {
-			sf.t.Errorf("setInt(): GOOD-2 hour(%v)!=0", sf.ct.parser.Hour().Get())
+		if ct.парсер.Hour().Get() != 0 {
+			sf.t.Errorf("setInt(): GOOD-2 hour(%v)!=0", sf.ct.парсер.Hour().Get())
 		}
-		if ct.parser.Min().Get() != 2 {
-			sf.t.Errorf("setInt(): GOOD-2 min(%v)!=2", sf.ct.parser.Min().Get())
+		if ct.парсер.Min().Get() != 2 {
+			sf.t.Errorf("setInt(): GOOD-2 min(%v)!=2", sf.ct.парсер.Min().Get())
 		}
-		if ct.parser.Sec().Get() != 1 {
-			sf.t.Errorf("setInt(): GOOD-2 sec(%v)!=1", sf.ct.parser.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)
@@ -210,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.parser.Hour().Get() != 2 {
-			sf.t.Errorf("setInt(): GOOD-3 hour(%v)!=2", sf.ct.parser.Hour().Get())
+		if ct.парсер.Hour().Get() != 2 {
+			sf.t.Errorf("setInt(): GOOD-3 hour(%v)!=2", sf.ct.парсер.Hour().Get())
 		}
-		if ct.parser.Min().Get() != 0 {
-			sf.t.Errorf("setInt(): GOOD-3 min(%v)!=0", sf.ct.parser.Min().Get())
+		if ct.парсер.Min().Get() != 0 {
+			sf.t.Errorf("setInt(): GOOD-3 min(%v)!=0", sf.ct.парсер.Min().Get())
 		}
-		if ct.parser.Sec().Get() != 3 {
-			sf.t.Errorf("setInt(): GOOD-3 sec(%v)!=3", sf.ct.parser.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)
@@ -232,7 +238,7 @@ func (sf *tester) createBad1() {
 			sf.t.Errorf("createBad1(): panic==nil")
 		}
 	}()
-	sf.ct = NewCountTime(nil, 0)
+	sf.ct = НовВремОбрат(nil, 0)
 	if sf.ct != nil {
 		sf.t.Errorf("createBad1(): countTime!=nil")
 	}
@@ -242,10 +248,11 @@ func (sf *tester) createBad1() {
 func (sf *tester) createGood1() {
 	defer func() {
 		if _panic := recover(); _panic != nil {
-			sf.t.Errorf("createGood1(): panic=%v", _panic)
+			sf.t.Errorf("createGood1(): panic=\n\t%v", _panic)
 		}
 	}()
-	ct := NewCountTime(sf.zone, 1)
+	sf.zone = mock_zone.НовМокСцена()
+	ct := НовВремОбрат(sf.zone, 1)
 	if ct == nil {
 		sf.t.Errorf("createGood1(): countTime==nil")
 	}

pkg/components/section/section.go

@@ -30,7 +30,7 @@ func NewSection(bot types.ИБот, zoneName, strControl string) (*Section, erro
 	}
 	sf := &Section{
 		Zone:      zone,
-		countDown: down_time.NewCountTime(zone, 5),
+		countDown: down_time.НовВремОбрат(zone, 5),
 		mode:      section_mode.NewSectionMode(),
 	}
 	sf.lstString, err = lst_string.NewLstString(strControl)
@@ -55,7 +55,7 @@ func (sf *Section) СписПолучить() []string {
 
 // SetCountDown -- устанавливает новое значение обратного счётчика времени (int)
 func (sf *Section) SetCountDown(sec int) error {
-	sf.countDown = down_time.NewCountTime(sf, sec)
+	sf.countDown = down_time.НовВремОбрат(sf, sec)
 	// if err := sf.countDown.Set(sec); err != nil {
 	// 	return fmt.Errorf("Section.SetCountDown(): err=\n\t%w", err)
 	// }
@@ -67,7 +67,7 @@ func (sf *Section) ParseCountDown(sec string) error {
 	pt := parsetime.NewParseTime()
 	pt.Parse(sec)
 	_sec := pt.Get()
-	sf.countDown = down_time.NewCountTime(sf, _sec)
+	sf.countDown = down_time.НовВремОбрат(sf, _sec)
 	// if err := sf.countDown.Set(sec); err != nil {
 	// 	return fmt.Errorf("Section.SetCountDown(): err=\n\t%w", err)
 	// }

pkg/mock/mock_zone/mock_zone.go

@@ -1,6 +1,33 @@
 // package mock_zone -- мок-область зоны игры
 package mock_zone
 
+import (
+	"context"
+	"wartank/pkg/types"
+)
+
 // МокОбласть -- мок-область зоны игры
-type МокОбласть struct {
+type МокСцена struct {
+	кнт context.Context
+}
+
+func НовМокСцена() *МокСцена {
+	сам := &МокСцена{
+		кнт: context.Background(),
+	}
+	_ = types.ИСцена(сам)
+	return сам
+}
+
+func (сам *МокСцена) Кнт() context.Context {
+	return сам.кнт
+}
+
+func (сам *МокСцена) Имя() string {
+	return "МокСцена"
+}
+func (сам *МокСцена) Закончить() {}
+
+func (сам *МокСцена) Бот() types.ИБот {
+	return nil
 }

pkg/store/store.go

@@ -34,7 +34,7 @@ func NewStore(app types.ИСервер) (*Store, error) {
 	if err := sf.open(); err != nil {
 		return nil, fmt.Errorf("NewStore(): in open store, err=%w", err)
 	}
-	sf.isWork.Set()
+	sf.isWork.Уст()
 	go sf.close()
 	sf.app.Wg().Add(strStore)
 	sf.app.Slog().Infof("NewStore(): run")
@@ -53,7 +53,7 @@ func (sf *Store) open() error {
 
 // Get -- возвращает запись по ключу
 func (sf *Store) Get(key string) (string, error) {
-	if !sf.isWork.Get() {
+	if !sf.isWork.Получ() {
 		return "", fmt.Errorf("Store.Get():  store is close")
 	}
 	binData, err := sf.db.Get([]byte(key), nil)
@@ -65,7 +65,7 @@ func (sf *Store) Get(key string) (string, error) {
 
 // Put -- помещает запись по ключу
 func (sf *Store) Put(key string, val string) error {
-	if !sf.isWork.Get() {
+	if !sf.isWork.Получ() {
 		return fmt.Errorf("Store.Put():  store is close")
 	}
 	if err := sf.db.Put([]byte(key), []byte(val), nil); err != nil {
@@ -92,10 +92,10 @@ func (sf *Store) Find(prefix string) (map[string]string, error) {
 
 func (sf *Store) close() {
 	<-sf.app.Done()
-	if !sf.isWork.Get() {
+	if !sf.isWork.Получ() {
 		return
 	}
 	sf.app.Wg().Done(strStore)
-	sf.isWork.Reset()
+	sf.isWork.Сброс()
 	sf.app.Slog().Infof("NewStore(): close")
 }

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

@@ -212,7 +212,7 @@ func (sf *DivWar) DivWar() {
 		return
 	}
 	// Цикл ожидания окончания сражения
-	for !sf.divon.ЕслиКонец().Get() {
+	for !sf.divon.ЕслиКонец().Получ() {
 		time.Sleep(time.Second * 1)
 	}
 

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

@@ -70,16 +70,16 @@ func NewDivWarOn(bot types.ИБот) (*DivWarOn, error) {
 func (sf *DivWarOn) makeTick() {
 	defer func() {
 		close(sf.chTick)
-		sf.isEnd.Set()
+		sf.isEnd.Уст()
 	}()
-	for !sf.isEnd.Get() {
+	for !sf.isEnd.Получ() {
 		select {
 		case <-sf.bot.Кнт().Done(): // Отмена контекста приложения
 			return
 		case <-sf.ctxDivWar.Done(): // Битва закончилась
 			return
 		default:
-			if sf.isEnd.Get() {
+			if sf.isEnd.Получ() {
 				return
 			}
 			sf.chTick <- 1
@@ -101,13 +101,13 @@ func (sf *DivWarOn) run() {
 		sf.health, err = health.NewHealth(sf, sf.shot.IsEnd(), sf.login)
 		if err != nil {
 			// log._rintf("ERRO DivWarOn.Run(): при создании здоровья танка, err=\n\t%v\n", err)
-			sf.shot.IsEnd().Reset()
+			sf.shot.IsEnd().Сброс()
 			return
 		}
 		sf.manevr, err = manevr.NewManevr(sf, sf.shot.IsEnd())
 		if err != nil {
 			// log._rintf("ERRO DivWarOn.Run(): при создании маневра танка, err=\n\t%v\n", err)
-			sf.shot.IsEnd().Reset()
+			sf.shot.IsEnd().Сброс()
 			return
 		}
 	}
@@ -131,7 +131,7 @@ func (sf *DivWarOn) Сеть() types.ISectionNet {
 // Проверяет окончание сражения
 func (sf *DivWarOn) checkEnd() bool {
 	defer func() {
-		if sf.isEnd.Get() {
+		if sf.isEnd.Получ() {
 			sf.fnCancelDivWar()
 			// log._rintf("DivWarOn.checkEnd(): сражение завершено\n")
 		}
@@ -139,18 +139,18 @@ func (sf *DivWarOn) checkEnd() bool {
 
 	if err := sf.net.UpdateLst(); err != nil {
 		// log._rintf("WARN DivWarOn.checkEnd(): при обновлении lstDivWarOn, err=\n\t%v\n", err)
-		sf.isEnd.Set()
+		sf.isEnd.Уст()
 		sf.fnCancelDivWar()
 		return true
 	}
 	lstDivWarOn := sf.СписПолучить()
 	for _, strOut := range lstDivWarOn {
 		if strings.Contains(strOut, `" class="simple-but gray"><span><span>ОБЫЧНЫЕ</span></span></a>`) {
-			sf.isEnd.Reset()
+			sf.isEnd.Сброс()
 			return false
 		}
 	}
-	sf.isEnd.Set()
+	sf.isEnd.Уст()
 	sf.fnCancelDivWar()
 	return true
 }

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

@@ -105,20 +105,20 @@ func (sf *Health) run() {
 	for {
 		select {
 		case <-sf.ctxBattle.Done():
-			sf.isEnd.Set()
+			sf.isEnd.Уст()
 			return
 		case <-sf.chTick:
 			if err := sf.findHealth(); err != nil { // Найти свой здоровье
 				// log._rintf("ERRO Health.run(): при попытке найти здоровье, err=\n\t%v\n", err)
 			}
 			sf.findRepairTime()
-			if sf.ВыстрелБлок().Get() {
-				if sf.isRepair.Get() {
+			if sf.ВыстрелБлок().Получ() {
+				if sf.isRepair.Получ() {
 					go sf.repair()
 				}
 				continue
 			}
-			if sf.isRepair.Get() {
+			if sf.isRepair.Получ() {
 				go sf.repair()
 			}
 		}
@@ -132,7 +132,7 @@ func (sf *Health) Full() int {
 
 // IsDeath -- возвращает признак мертвичины танка
 func (sf *Health) IsDeath() bool {
-	if sf.isEnd.Get() {
+	if sf.isEnd.Получ() {
 		sf.fnCancel()
 		return true
 	}
@@ -141,12 +141,12 @@ func (sf *Health) IsDeath() bool {
 		if strings.Contains(strOut, `>Ваш танк подбит.`) {
 			// log._rintf("INFO Health.repair(): танк подбит\n")
 			sf.temp.Set(0)
-			sf.isEnd.Set()
+			sf.isEnd.Уст()
 			sf.CancelBattle()
 			return true
 		}
 	}
-	return sf.isEnd.Get()
+	return sf.isEnd.Получ()
 }
 
 // Ищет время восстановления ремки
@@ -187,7 +187,7 @@ func (sf *Health) findRepairTime() {
 	lstTime := strings.Split(strOut, `ILinkListener-currentControl-repairLink" class="simple-but blue"><span><span>`)
 	if len(lstTime) < 2 {
 		// log._rintf("ERRO Health.findRepair(): при попытке получить ссылку на ремонт, strOut=\n%v\n", strOut)
-		sf.isEnd.Set()
+		sf.isEnd.Уст()
 		sf.CancelBattle()
 		return
 	}
@@ -227,13 +227,13 @@ func (sf *Health) repair() {
 	lstBattleOn, err := sf.Сеть().Get(strLink)
 	if err != nil {
 		// log._rintf("ERRO Health.repair(): при выполнении GET-команды ремонта, err=\n\t%v\n", err)
-		sf.isEnd.Set()
+		sf.isEnd.Уст()
 		sf.CancelBattle()
 		return
 	}
 	if err = sf.СтрОбновить(lstBattleOn); err != nil {
 		// log._rintf("ERRO Health.repair(): при обновлении lstBattle, err=\n\t%v\n", err)
-		sf.isEnd.Set()
+		sf.isEnd.Уст()
 		sf.CancelBattle()
 		return
 	}
@@ -251,7 +251,7 @@ func (sf *Health) findHealth() error {
 	)
 	if len(lstBattle) == 0 { // Принудительно обновим сражение
 		if err := sf.Сеть().UpdateLst(); err != nil {
-			sf.isEnd.Set()
+			sf.isEnd.Уст()
 			sf.fnCancel()
 			return fmt.Errorf("Health.findHealth(): после принудительного обновления lsBattleOn, err=\n\t%w", err)
 		}
@@ -263,7 +263,7 @@ func (sf *Health) findHealth() error {
 		}
 	}
 	if !isFind { // Свой танк не найден
-		sf.isEnd.Set()
+		sf.isEnd.Уст()
 		sf.fnCancel()
 		return fmt.Errorf("Health.findHealth(): своё здоровье не найдено")
 	}
@@ -276,7 +276,7 @@ func (sf *Health) findHealth() error {
 	strHealth = lstHealth[0]
 	iHealth, err := strconv.Atoi(strHealth)
 	if err != nil {
-		sf.isEnd.Set()
+		sf.isEnd.Уст()
 		sf.CancelBattle()
 		return fmt.Errorf("Health.findHealth(): здоровье(%v) не число, err=%w", strHealth, err)
 	}
@@ -296,8 +296,8 @@ func (sf *Health) setHealth(val int) {
 		sf.full.Set(val)
 		sf.temp.Set(val)
 		sf.deltaOld = 0
-		sf.ВыстрелБлок().Reset()
-		sf.isRepair.Reset()
+		sf.ВыстрелБлок().Сброс()
+		sf.isRepair.Сброс()
 		return
 	}
 
@@ -311,38 +311,38 @@ func (sf *Health) setHealth(val int) {
 	}
 
 	switch {
-	case sf.isEnd.Get():
+	case sf.isEnd.Получ():
 		sf.temp.Set(0)
-		sf.isEnd.Set()
+		sf.isEnd.Уст()
 		sf.CancelBattle()
 		return
 	case val == 0:
 		sf.temp.Set(0)
-		sf.isEnd.Set()
+		sf.isEnd.Уст()
 		sf.CancelBattle()
 		return
 	case val <= 500: // Запретить стрельбу
-		sf.ВыстрелБлок().Set() // Установить запрет стрельбы пока слабое здоровье
-		sf.isRepair.Set()
+		sf.ВыстрелБлок().Уст() // Установить запрет стрельбы пока слабое здоровье
+		sf.isRepair.Уст()
 		// log._rintf("WARN Health.setHealth(): низкий уровень здоровья(%v)\n", val)
 		sf.Манёвр()
 	case val > 500: // Разрешить стрельбы
-		sf.ВыстрелБлок().Reset()
-		sf.isRepair.Reset()
+		sf.ВыстрелБлок().Сброс()
+		sf.isRepair.Сброс()
 		if delta > sf.full.Get()*4/10 { // Проверить на критичность падения здоровья на 40%
 			// log._rintf("WARN Health.setHealth(): большая разовая потеря здоровья(%v)\n", delta)
 			sf.Манёвр()
-			sf.isRepair.Set()
+			sf.isRepair.Уст()
 			return
 		}
 	}
 
-	isMask := sf.ВыстрелБлок().Get()
+	isMask := sf.ВыстрелБлок().Получ()
 	switch isMask {
 	case true:
 		sf.countLow++
 		if sf.countLow >= 200 {
-			sf.isEnd.Set()
+			sf.isEnd.Уст()
 			sf.CancelBattle()
 			return
 		}
@@ -351,8 +351,8 @@ func (sf *Health) setHealth(val int) {
 	}
 	if val == sf.full.Get() {
 		sf.temp.Set(val)
-		sf.isRepair.Reset()
-		sf.ВыстрелБлок().Reset()
+		sf.isRepair.Сброс()
+		sf.ВыстрелБлок().Сброс()
 		sf.countLow = 0
 	}
 }

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

@@ -108,7 +108,7 @@ func (sf *Manevr) findManevrTime() {
 			time.Sleep(time.Second * 1)
 			return
 		}
-		if sf.isEnd.Get() {
+		if sf.isEnd.Получ() {
 			time.Sleep(time.Second * 1)
 			return
 		}

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

@@ -68,7 +68,7 @@ func NewShot(divWar types.ИДивизияВойнаДействие, login stri
 // Генерирует тики, когда можно стрелять
 func (sf *Shot) makeTick() {
 	defer func() {
-		sf.isEnd.Set()
+		sf.isEnd.Уст()
 		close(sf.chTick)
 		sf.CancelBattle()
 		// log._rintf("Shot.makeTick(): сражение завершёно\n")
@@ -79,10 +79,10 @@ func (sf *Shot) makeTick() {
 		case <-sf.ctxEnd.Done():
 			return
 		default:
-			if sf.isEnd.Get() { // Битва закончилась
+			if sf.isEnd.Получ() { // Битва закончилась
 				return
 			}
-			switch sf.ВыстрелБлок().Get() { // Проверить запрет на стрельбу при слабом здоровье
+			switch sf.ВыстрелБлок().Получ() { // Проверить запрет на стрельбу при слабом здоровье
 			case true:
 				// log._rintf("WARN Shot.run(): запрет на выстрел\n")
 				countMasking++
@@ -125,7 +125,7 @@ func (sf *Shot) shot() {
 	if err := sf.Сеть().UpdateLst(); err != nil { // Проверка на непосредственно битву
 		// <span>закончилась 00:00:07 назад</span>
 		// log._rintf("ERRO Shot.shot(): при обновлении lstBattleOn, err=\n\t%v\n", err)
-		sf.isEnd.Set()
+		sf.isEnd.Уст()
 		sf.CancelBattle()
 		return
 	}
@@ -144,7 +144,7 @@ func (sf *Shot) shot() {
 	}
 	if !isFind {
 		// log._rintf("WARN Shot.shot(): не найдены ссылка на выстрел\n")
-		sf.isEnd.Set()
+		sf.isEnd.Уст()
 		sf.CancelBattle()
 		return
 	}
@@ -155,13 +155,13 @@ func (sf *Shot) shot() {
 	lstBattle, err = sf.Сеть().Get(strLink)
 	if err != nil {
 		// log._rintf("ERRO Shot.shot(): при исполнении GET-команды выстрела обычным снарядом, err=\n\t%v\n", err)
-		sf.isEnd.Set()
+		sf.isEnd.Уст()
 		sf.CancelBattle()
 		return
 	}
 	if err = sf.СтрОбновить(lstBattle); err != nil {
 		// log._rintf("ERRO Shot.shot(): при обновлении lstBattle, err=\n\t%v\n", err)
-		sf.isEnd.Set()
+		sf.isEnd.Уст()
 		sf.CancelBattle()
 		return
 	}

server/serv_bots/warbot/warbot.go

@@ -127,7 +127,7 @@ func создатьЯдроВарБот(server types.ИСервер, config *war
 		return nil, fmt.Errorf("NewWarBot(): bot(%q) in make IAngar, err=\n\t%w", sf.Имя(), err)
 	}
 	if sf.конфиг.ЕслиАвтозапуск_ {
-		sf.еслиАвтозапуск.Set()
+		sf.еслиАвтозапуск.Уст()
 		sf.Пуск()
 	}
 	return sf, nil
@@ -140,7 +140,7 @@ func (sf *ВарБот) Сервер() types.ИСервер {
 
 // ЕслиПуск -- возвращает признак, что бот подключен
 func (sf *ВарБот) ЕслиПуск() bool {
-	return sf.еслиРаботает.Get()
+	return sf.еслиРаботает.Получ()
 }
 
 // Имя -- возвращает имя бота
@@ -155,13 +155,13 @@ func (sf *ВарБот) Пароль() string {
 
 // Пуск -- запускает бот в работу
 func (sf *ВарБот) Пуск() (err error) {
-	if sf.еслиРаботает.Get() {
+	if sf.еслиРаботает.Получ() {
 		return nil
 	}
 	if err := sf.ангар.Пуск(); err != nil {
 		return fmt.Errorf("WarBot.Run(): bot(%q) in run angar, err=\n\t%w", sf.Имя(), err)
 	}
-	sf.еслиРаботает.Set()
+	sf.еслиРаботает.Уст()
 	return nil
 }
 
@@ -187,13 +187,13 @@ func (sf *ВарБот) Сеть() types.ИБотСеть {
 
 // АвтоИграЕсли -- возвращает признак автоматичского запуска бота
 func (sf *ВарБот) АвтоИграЕсли() bool {
-	return sf.еслиАвтозапуск.Get()
+	return sf.еслиАвтозапуск.Получ()
 }
 
 // АвтоИграУст -- устанавливает признак автоматического запуска бота
 func (sf *ВарБот) АвтоИграУст() {
 	log.Printf("WarBot.SetAutoGame()")
-	sf.еслиАвтозапуск.Set()
+	sf.еслиАвтозапуск.Уст()
 	sf.конфиг.ЕслиАвтозапуск_ = true
 	sf.saveConfig()
 }
@@ -201,7 +201,7 @@ func (sf *ВарБот) АвтоИграУст() {
 // АвтоИграСброс -- сбрасывает признак автоматического запуска бота
 func (sf *ВарБот) АвтоИграСброс() {
 	log.Printf("WarBot.ResetAutoGame()")
-	sf.еслиАвтозапуск.Set()
+	sf.еслиАвтозапуск.Уст()
 	sf.конфиг.ЕслиАвтозапуск_ = false
 	sf.saveConfig()
 }

server/serv_bots/warbot/warbot_net/warbot_net.go

@@ -50,7 +50,7 @@ func NewWarBotNet(bot types.ИБот) (*WarBotNet, error) {
 			return nil, fmt.Errorf("NewWarBotNet(): in create BotNetLogin, err=\n\t%w", err)
 		}
 	}
-	sf.isOnline.Set()
+	sf.isOnline.Уст()
 	_ = types.ИБотСеть(sf)
 	return sf, nil
 }