d06 Исправления, упращения после линтера

Makefile

@@ -53,4 +53,4 @@ lint:
 	go fmt ./...
 	golangci-lint run ./cmd/server/...
 	golangci-lint run ./pkg/...
-	golangci-lint run ./internal/...
+	golangci-lint run ./server/...

cmd/server/main.go

@@ -52,7 +52,7 @@ func main() {
 	}
 	go func() {
 		time.Sleep(time.Minute * 20)
-		serv.CancelApp()
+		serv.Отменить()
 	}()
 	if err := serv.Run(); err != nil {
 		log.Printf("main(): in run server, err=\n\t%v\n", err)

pkg/components/kernel/keeper/keeper.go

@@ -7,6 +7,7 @@ package keeper
 */
 
 import (
+	"fmt"
 	"os"
 	"os/signal"
 	"syscall"
@@ -14,43 +15,53 @@ import (
 	"wartank/pkg/types"
 )
 
-// Keeper -- сторож системных и внутренних сигналов
-type Keeper struct {
+// Сторож -- сторож системных и внутренних сигналов
+type Сторож struct {
 	kernel types.ИЯдро
-	slog   types.ISlog
+	слог   types.ИСлог
 	chSys  chan os.Signal
 }
 
-// NewKeeper -- возвращает глобальный объект сторожа *Keeper
-func NewKeeper(kernel types.ИЯдро) *Keeper {
+const (
+	стрСторож = "сторож"
+)
+
+// НовСторож -- возвращает глобальный объект сторожа *Keeper
+func НовСторож(kernel types.ИЯдро) *Сторож {
 	if kernel == nil {
 		panic("GetKeeper(): IKernel is nil")
 	}
 
-	сам := &Keeper{
+	сам := &Сторож{
 		kernel: kernel,
-		slog:   kernel.Slog(),
+		слог:   kernel.Слог(),
 		chSys:  make(chan os.Signal, 3),
 	}
-	сам.kernel.Wg().Add("keeper")
+	ош := сам.kernel.Wg().Add(стрСторож)
+	if ош != nil {
+		panic(fmt.Sprintf("НовСторож(): при добавлении группы ожидания %q, ош=\n\t%v\n", стрСторож, ош.Error()))
+	}
 	signal.Notify(сам.chSys, os.Interrupt, syscall.SIGTERM)
 	go сам.run()
-	сам.slog.Debugf("NewKeeper()\n")
+	сам.слог.Отладка("NewKeeper()\n")
 	return сам
 }
 
 // Слушает сигналы завершения изнутри и снаружи
-func (сам *Keeper) run() {
-	сам.slog.Infof("Keeper.run()\n")
+func (сам *Сторож) run() {
+	сам.слог.Инфо("Keeper.run()\n")
 	defer func() {
-		сам.slog.Infof("Keeper.run(): end\n")
-		сам.kernel.Wg().Done("keeper")
+		сам.слог.Инфо("Keeper.run(): end\n")
+		ош := сам.kernel.Wg().Done(стрСторож)
+		if ош != nil {
+			сам.слог.Ошибка("Keeper.run(): при удалении группы ожидания, ош=\n\t%w", ош)
+		}
 	}()
 	select {
 	case sig := <-сам.kernel.Done(): // глобальная отмена контекста
-		сам.slog.Infof("Keeper.run(): intern_sig=%q\n", sig)
+		сам.слог.Инфо("Keeper.run(): intern_sig=%q\n", sig)
 	case sig := <-сам.chSys: // Системный сигнал закрытия
-		сам.kernel.CancelApp()
-		сам.slog.Infof("Keeper.run(): sys_sig=%v\n", sig)
+		сам.kernel.Отменить()
+		сам.слог.Инфо("Keeper.run(): sys_sig=%v\n", sig)
 	}
 }

pkg/components/kernel/keeper/keeper_test.go

@@ -21,7 +21,7 @@ type tester struct {
 	t    *testing.T
 	err  error
 	me   *mock_env.МокОкружение
-	kp   *Keeper
+	kp   *Сторож
 	kern types.ИЯдро
 }
 
@@ -40,7 +40,7 @@ func (сам *tester) cancel() {
 	сам.kp.chSys <- syscall.SIGTERM
 	time.Sleep(time.Microsecond * 150)
 	сам.createGood1()
-	сам.kern.CancelApp()
+	сам.kern.Отменить()
 	time.Sleep(time.Microsecond * 150)
 }
 
@@ -63,11 +63,11 @@ func (сам *tester) createGood1() {
 	}
 	сам.kern = mockkernel.NewMockKernel()
 	ядро := сам.kern.(*mockkernel.MockKernel)
-	ядро.Slog_, сам.err = slog.NewSlog(сам.kern)
+	ядро.Slog_, сам.err = slog.НовСлог(сам.kern)
 	if сам.err != nil {
 		сам.t.Errorf("createGood1(): in create ISlog, err=\n\t%v", сам.err)
 	}
-	сам.kp = NewKeeper(сам.kern)
+	сам.kp = НовСторож(сам.kern)
 	if сам.kp == nil {
 		сам.t.Errorf("createGood1(): keep==nil")
 	}
@@ -83,5 +83,5 @@ func (сам *tester) createBad1() {
 			сам.t.Errorf("createBad1(): keep!=nil")
 		}
 	}()
-	сам.kp = NewKeeper(nil)
+	сам.kp = НовСторож(nil)
 }

pkg/components/kernel/kernel.go

@@ -24,8 +24,8 @@ type Ядро struct {
 	ctxBg    context.Context  // Неотменяемый контекст приложения
 	ctxApp   context.Context  // Отменяемый контекст приложения
 	fnCancel func()           // Функция отмены приложения
-	keeper   *keeper.Keeper   // Сторож системных сигналов
-	слог     *slog.Slog       // Логгер в два вывода
+	keeper   *keeper.Сторож   // Сторож системных сигналов
+	слог     *slog.Слог       // Логгер в два вывода
 	wg       *wgname.WgName   // Групповое ожидание частей приложения
 	хран     types.ИХранилище // Хранилище данных
 	блок     sync.Mutex
@@ -46,18 +46,18 @@ func НовЯдро() (types.ИЯдро, error) {
 		return nil, fmt.Errorf("НовЯдро(): in creste IStore, err=%w", ош)
 	}
 	сам.блок.Lock()
-	сам.слог, ош = slog.NewSlog(сам)
+	сам.слог, ош = slog.НовСлог(сам)
 	сам.блок.Unlock()
 	if ош != nil {
 		return nil, fmt.Errorf("НовЯдро(): in creste ISlog, err=%w", ош)
 	}
-	сам.слог.Debugf("НовЯдро()")
-	сам.keeper = keeper.NewKeeper(сам)
+	сам.слог.Отладка("НовЯдро()")
+	сам.keeper = keeper.НовСторож(сам)
 	return сам, nil
 }
 
-// Store -- возвращает хранилище данных
-func (сам *Ядро) Store() types.ИХранилище {
+// Хранилище -- возвращает хранилище данных
+func (сам *Ядро) Хранилище() types.ИХранилище {
 	return сам.хран
 }
 
@@ -66,8 +66,8 @@ func (сам *Ядро) Wg() types.IWgName {
 	return сам.wg
 }
 
-// CtxApp -- возвращает глобальный контекст приложения
-func (сам *Ядро) CtxApp() context.Context {
+// Контекст -- возвращает глобальный контекст приложения
+func (сам *Ядро) Контекст() context.Context {
 	return сам.ctxApp
 }
 
@@ -76,15 +76,15 @@ func (сам *Ядро) Done() <-chan struct{} {
 	return сам.ctxApp.Done()
 }
 
-// CancelApp -- отменяет глобальный контекст приложения
-func (сам *Ядро) CancelApp() {
+// Отменить -- отменяет глобальный контекст приложения
+func (сам *Ядро) Отменить() {
 	сам.блок.Lock()
 	defer сам.блок.Unlock()
-	сам.слог.Infof("Kernel.CancelApp()\n")
+	сам.слог.Инфо("Kernel.CancelApp()\n")
 	сам.fnCancel()
 }
 
-// Slog -- возвращает глобальный лог приложения
-func (сам *Ядро) Slog() types.ISlog {
+// Слог -- возвращает глобальный лог приложения
+func (сам *Ядро) Слог() types.ИСлог {
 	return сам.слог
 }

pkg/components/kernel/kernel_test.go

@@ -34,11 +34,11 @@ func (сам *tester) create() {
 	if wg := сам.kern.Wg(); wg == nil {
 		сам.t.Errorf("create(): wg==nil\n")
 	}
-	if ctx := сам.kern.CtxApp(); ctx == nil {
+	if ctx := сам.kern.Контекст(); ctx == nil {
 		сам.t.Errorf("create(): ctx==nil\n")
 	}
-	if slog := сам.kern.Slog(); slog == nil {
+	if slog := сам.kern.Слог(); slog == nil {
 		сам.t.Errorf("create(): slog==nil\n")
 	}
-	сам.kern.CancelApp()
+	сам.kern.Отменить()
 }

pkg/components/kernel/slog/slog.go

@@ -2,6 +2,7 @@ package slog
 
 import (
 	"fmt"
+	"log"
 	"strings"
 	"sync"
 	"time"
@@ -25,44 +26,47 @@ const (
 	LevelError
 )
 
-// Slog -- лог событий для записи
-type Slog struct {
+// Слог -- лог событий для записи
+type Слог struct {
 	kern   types.ИЯдро
 	buf    strings.Builder
 	block  sync.RWMutex
-	lf     *slog_file.SlogFile
+	lf     *slog_file.СлогФайл
 	lt     *slog_term.SlogTerm
 	isWork *safe_bool.БезопБул
 	level  int // Уровень логирования
 }
 
-// NewSlog -- возвращает объект логирования
-func NewSlog(kern types.ИЯдро) (*Slog, error) {
+// НовСлог -- возвращает объект логирования
+func НовСлог(kern types.ИЯдро) (*Слог, error) {
 	if kern == nil {
 		return nil, fmt.Errorf("NewSlog(): IKernel is nil")
 	}
-	сам := &Slog{
+	сам := &Слог{
 		kern:   kern,
 		buf:    strings.Builder{},
 		lt:     slog_term.NewSlogTerm(),
 		isWork: safe_bool.НовБезопБул(),
 		level:  LevelDebug,
 	}
-	lf, err := slog_file.NewSlogFile(kern, "test")
+	lf, err := slog_file.НовСлогФайл(kern, "test")
 	if err != nil {
-		return nil, fmt.Errorf("NewSlog(): in create SlogFile, err=\n\t%w", err)
+		return nil, fmt.Errorf("НовСлог(): in create SlogFile, err=\n\t%w", err)
 	}
 	сам.lf = lf
 
 	go сам.close()
 	сам.isWork.Уст()
-	сам.kern.Wg().Add(strSlog)
-	сам.Infof("NewSlog()\n")
+	ош := сам.kern.Wg().Add(strSlog)
+	if ош != nil {
+		return nil, fmt.Errorf("НовСлог(): при добавлении группы ожидания %q, ош=\n\t%w", strSlog, ош)
+	}
+	сам.Инфо("НовСлог()\n")
 	return сам, nil
 }
 
-// Debugf -- выводит в лог отладочную инфу
-func (сам *Slog) Debugf(str string, lstVal ...interface{}) {
+// Отладка -- выводит в лог отладочную инфу
+func (сам *Слог) Отладка(str string, lstVal ...interface{}) {
 	сам.block.Lock()
 	defer сам.block.Unlock()
 	if !сам.isWork.Получ() {
@@ -71,8 +75,8 @@ func (сам *Slog) Debugf(str string, lstVal ...interface{}) {
 	сам.printf("DEBUG", str, lstVal...)
 }
 
-// Infof -- выводит в лог дежурную инфу
-func (сам *Slog) Infof(str string, lstVal ...interface{}) {
+// Инфо -- выводит в лог дежурную инфу
+func (сам *Слог) Инфо(str string, lstVal ...interface{}) {
 	сам.block.Lock()
 	defer сам.block.Unlock()
 	if !сам.isWork.Получ() {
@@ -81,8 +85,8 @@ func (сам *Slog) Infof(str string, lstVal ...interface{}) {
 	сам.printf("INFO", str, lstVal...)
 }
 
-// Warnf -- выводит в лог предупредительную инфу
-func (сам *Slog) Warnf(str string, lstVal ...interface{}) {
+// Внимание -- выводит в лог предупредительную инфу
+func (сам *Слог) Внимание(str string, lstVal ...interface{}) {
 	сам.block.Lock()
 	defer сам.block.Unlock()
 	if !сам.isWork.Получ() {
@@ -91,8 +95,8 @@ func (сам *Slog) Warnf(str string, lstVal ...interface{}) {
 	сам.printf("WARN", str, lstVal...)
 }
 
-// Errorf -- выводит в лог инфу об ошибках
-func (сам *Slog) Errorf(str string, lstVal ...interface{}) {
+// Ошибка -- выводит в лог инфу об ошибках
+func (сам *Слог) Ошибка(str string, lstVal ...interface{}) {
 	сам.block.Lock()
 	defer сам.block.Unlock()
 	if !сам.isWork.Получ() {
@@ -102,7 +106,7 @@ func (сам *Slog) Errorf(str string, lstVal ...interface{}) {
 }
 
 // Внутренний вызов без блокировки
-func (сам *Slog) printf(pref, str string, lstVal ...interface{}) {
+func (сам *Слог) printf(pref, str string, lstVal ...interface{}) {
 	style := ""
 	switch pref {
 	case "DEBUG": // Режим отладки
@@ -127,13 +131,17 @@ func (сам *Slog) printf(pref, str string, lstVal ...interface{}) {
 }
 
 // Ожидает закрытия приложения
-func (сам *Slog) close() {
+func (сам *Слог) close() {
 	<-сам.kern.Done()
 	сам.block.Lock()
+	defer сам.block.Unlock()
 	if !сам.isWork.Получ() {
 		return
 	}
 	сам.isWork.Сброс()
-	сам.kern.Wg().Done(strSlog)
-	сам.block.Unlock()
+	ош := сам.kern.Wg().Done(strSlog)
+	if ош != nil {
+		log.Printf("Слог.close(): при удалении группы ожидания, ош=\n\t%v", ош)
+	}
+	сам.kern.Отменить()
 }

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

@@ -3,7 +3,7 @@ package slog_file
 
 import (
 	"fmt"
-	// "log"
+	"log"
 	"os"
 	"sync"
 	"time"
@@ -17,8 +17,8 @@ const (
 	threadName = "slog_file"
 )
 
-// SlogFile -- бэкенд для вывода в файл
-type SlogFile struct {
+// СлогФайл -- бэкенд для вывода в файл
+type СлогФайл struct {
 	kern     types.ИЯдро
 	file     *os.File
 	fileName string
@@ -27,17 +27,17 @@ type SlogFile struct {
 	block    sync.Mutex
 }
 
-// NewSlogFile -- возвращает новый бэкенд логгера для вывода в файл
-func NewSlogFile(kern types.ИЯдро, build string) (*SlogFile, error) {
+// НовСлогФайл -- возвращает новый бэкенд логгера для вывода в файл
+func НовСлогФайл(kern types.ИЯдро, build string) (*СлогФайл, error) {
 	{ // Предусловия
 		if kern == nil {
-			return nil, fmt.Errorf("NewSlogFile(): IKernel is nil")
+			return nil, fmt.Errorf("НовСлогФайл(): ИЯдро is nil")
 		}
 		if build == "" {
-			return nil, fmt.Errorf("NewSlogFile(): strBuild is empty")
+			return nil, fmt.Errorf("НовСлогФайл(): strBuild is empty")
 		}
 	}
-	сам := &SlogFile{
+	сам := &СлогФайл{
 		kern:     kern,
 		fileName: cons.СамИмя + "_" + build + time.Now().UTC().Format("_2006-01-02 15:04:05.000") + ".log",
 		isWork:   safe_bool.НовБезопБул(),
@@ -47,35 +47,41 @@ func NewSlogFile(kern types.ИЯдро, build string) (*SlogFile, error) {
 	_ = os.MkdirAll("./log", 0700)
 	сам.fileName = "./log/" + сам.fileName
 	if err := сам.open(); err != nil {
-		return nil, fmt.Errorf("NewSlogFile(): in open log-file, err=%w", err)
+		return nil, fmt.Errorf("НовСлогФайл(): in open log-file, err=%w", err)
+	}
+	ош := сам.kern.Wg().Add(threadName)
+	if ош != nil {
+		return nil, fmt.Errorf("НовСлогФайл(): in Add %q, err=%w", threadName, ош)
 	}
-	сам.kern.Wg().Add(threadName)
 	go сам.run()
 	return сам, nil
 }
 
 // Открывает файл на запись
-func (сам *SlogFile) open() error {
+func (сам *СлогФайл) open() error {
 	file, err := os.OpenFile(сам.fileName, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0600)
 	if err != nil {
-		сам.kern.CancelApp()
-		return fmt.Errorf("NewSlogFile.open(): in open %q, err=%w", сам.fileName, err)
+		сам.kern.Отменить()
+		return fmt.Errorf("СлогФайл.open(): in open %q, err=%w", сам.fileName, err)
 	}
 	сам.file = file
 	return nil
 }
 
 // Запускает работу в отдельном потоке
-func (сам *SlogFile) run() {
+func (сам *СлогФайл) run() {
 	defer func() {
 		сам.isWork.Сброс()
 		сам.block.Lock()
 		defer сам.block.Unlock()
 		_ = сам.file.Close()
 		close(сам.chMsg)
-		сам.kern.Wg().Done(threadName)
+		ош := сам.kern.Wg().Done(threadName)
+		if ош != nil {
+			log.Printf("СлогФайл.run(): при удалении группы ожидания, ош=\n\t%v", ош)
+		}
 		// log._rintf("SlogFile.run(): end work\n")
-		сам.kern.CancelApp()
+		сам.kern.Отменить()
 	}()
 	for {
 		select {
@@ -83,7 +89,7 @@ func (сам *SlogFile) run() {
 			return
 		case msg := <-сам.chMsg:
 			if err := сам.write(msg); err != nil {
-				сам.kern.Slog().Errorf("SlogFile.run(): in write msg, err=\n\t%v", err)
+				сам.kern.Слог().Ошибка("СлогФайл.run(): in write msg, err=\n\t%v", err)
 				return
 			}
 		}
@@ -91,16 +97,16 @@ func (сам *SlogFile) run() {
 }
 
 // Внцтренни вызов записи
-func (сам *SlogFile) write(msg []byte) error {
+func (сам *СлогФайл) write(msg []byte) error {
 	_, err := сам.file.Write(msg)
 	if err != nil {
-		return fmt.Errorf("SlogFile.run(): in write file %q, err=\n\t%w", сам.fileName, err)
+		return fmt.Errorf("СлогФайл.run(): in write file %q, err=\n\t%w", сам.fileName, err)
 	}
 	return nil
 }
 
 // Write -- записывает данные в файл
-func (сам *SlogFile) Write(msg string) {
+func (сам *СлогФайл) Write(msg string) {
 	if !сам.isWork.Получ() {
 		return
 	}

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

@@ -19,7 +19,7 @@ type tester struct {
 	err  error
 	me   *mock_env.МокОкружение
 	kern types.ИЯдро
-	сам  *SlogFile
+	сам  *СлогФайл
 }
 
 func TestSlogFile(t *testing.T) {
@@ -46,7 +46,7 @@ func (сам *tester) writeBad1() {
 // закрытие логгера
 func (сам *tester) close() {
 	сам.t.Logf("=close=")
-	сам.kern.CancelApp()
+	сам.kern.Отменить()
 	сам.kern.Wg().Wait()
 	сам.сам.Write("")
 }
@@ -55,7 +55,7 @@ func (сам *tester) close() {
 func (сам *tester) cancel() {
 	сам.t.Logf("=cancal=")
 	сам.createGood1()
-	сам.kern.CancelApp()
+	сам.kern.Отменить()
 	сам.kern.Wg().Wait()
 }
 
@@ -76,7 +76,7 @@ func (сам *tester) create() {
 
 func (сам *tester) createGood1() {
 	сам.t.Logf("=createGood1=")
-	сам.сам, сам.err = NewSlogFile(сам.kern, "test")
+	сам.сам, сам.err = НовСлогФайл(сам.kern, "test")
 	if сам.err != nil {
 		сам.t.Errorf("createGood1(): err=%v", сам.err)
 	}
@@ -89,7 +89,7 @@ func (сам *tester) createGood1() {
 func (сам *tester) createBad2() {
 	сам.t.Logf("=createBad2=")
 	сам.kern = mockkernel.NewMockKernel()
-	сам.сам, сам.err = NewSlogFile(сам.kern, "")
+	сам.сам, сам.err = НовСлогФайл(сам.kern, "")
 	if сам.err == nil {
 		сам.t.Errorf("createBad2(): err == nil")
 	}
@@ -101,7 +101,7 @@ func (сам *tester) createBad2() {
 // Нет объекта ядра
 func (сам *tester) createBad1() {
 	сам.t.Logf("=createBad1=")
-	сам.сам, сам.err = NewSlogFile(nil, "test")
+	сам.сам, сам.err = НовСлогФайл(nil, "test")
 	if сам.err == nil {
 		сам.t.Errorf("createBad1(): err == nil")
 	}

pkg/components/kernel/slog/slog_test.go

@@ -19,7 +19,7 @@ type tester struct {
 	t    *testing.T
 	err  error
 	ядро types.ИЯдро
-	slog *Slog
+	slog *Слог
 }
 
 func TestSlog(t *testing.T) {
@@ -40,29 +40,29 @@ func (сам *tester) create() {
 
 func (сам *tester) createGood1() {
 	сам.t.Logf("=createGood1=\n")
-	сам.slog, сам.err = NewSlog(сам.ядро)
+	сам.slog, сам.err = НовСлог(сам.ядро)
 	if сам.err != nil {
 		сам.t.Errorf("createGood1(): in create ISlog, err=\n\t%v", сам.err)
 	}
 	ядро := сам.ядро.(*mockkernel.MockKernel)
 	ядро.Slog_ = сам.slog
-	сам.slog.Debugf("Проверка good1: %v\n", "test_123")
-	сам.slog.Infof("Проверка good1: %v\n", "test_123")
-	сам.slog.Warnf("Проверка good1: %v\n", "test_123")
-	сам.slog.Errorf("Проверка good1: %v\n", fmt.Errorf("test_123").Error())
-	сам.ядро.CancelApp()
+	сам.slog.Отладка("Проверка good1: %v\n", "test_123")
+	сам.slog.Инфо("Проверка good1: %v\n", "test_123")
+	сам.slog.Внимание("Проверка good1: %v\n", "test_123")
+	сам.slog.Ошибка("Проверка good1: %v\n", fmt.Errorf("test_123").Error())
+	сам.ядро.Отменить()
 	time.Sleep(time.Millisecond * 150)
-	сам.slog.Debugf("Проверка good1: %v\n", "test_123 bad")
-	сам.slog.Infof("")
-	сам.slog.Warnf("")
-	сам.slog.Errorf("")
+	сам.slog.Отладка("Проверка good1: %v\n", "test_123 bad")
+	сам.slog.Инфо("")
+	сам.slog.Внимание("")
+	сам.slog.Ошибка("")
 	сам.slog.close()
 }
 
 // Нет объекта ядра
 func (сам *tester) createBad2() {
 	сам.t.Logf("=createBad2=\n")
-	slog, err := NewSlog(nil)
+	slog, err := НовСлог(nil)
 	if err == nil {
 		сам.t.Errorf("createBad2(): in create ISlog, err==nil")
 	}

pkg/components/kernel/store/store.go

@@ -131,7 +131,7 @@ func (сам *Хранилище) открыть() error {
 
 // закрыть -- закрывает хранилище по требованию
 func (sf *Хранилище) закрыть() {
-	<-sf.ядро.CtxApp().Done()
+	<-sf.ядро.Контекст().Done()
 	sf.block.Lock()
 	defer sf.block.Unlock()
 	sf.isWork.Сброс()

pkg/components/wrag/wrag.go

@@ -1,11 +1,11 @@
 package wrag
 
 import (
+	"log"
+
 	"strconv"
 	"strings"
 	"wartank/pkg/types"
-
-	"github.com/sirupsen/logrus"
 )
 
 /*
@@ -46,7 +46,7 @@ func (сам *Wrag) update(lstBattleOn []string) {
 		}
 	}
 	if !еслиНайдено { // Не нашёл метку врага
-		logrus.Errorf("Wrag.update(): не нашёл имя врага")
+		log.Printf("Wrag.update(): не нашёл имя врага")
 		сам.health = 800
 		return
 	}
@@ -59,7 +59,7 @@ func (сам *Wrag) update(lstBattleOn []string) {
 	strHealth = lstHealth[0]
 	iHealth, err := strconv.Atoi(strHealth)
 	if err != nil {
-		logrus.WithError(err).Errorf("Wrag.update(): здоровье(%v) не число", strHealth)
+		log.Printf("Wrag.update(): здоровье(%v) не число, err=\n\t%v\n", strHealth,err)
 		сам.health = 800
 		return
 	}

pkg/mock/mockkernel/mockkernel.go

@@ -22,7 +22,7 @@ type MockKernel struct {
 	ctxApp   context.Context // глобальный отменяемый контекст приложения
 	fnCancel func()          // Функия глобальной отмены контекста приложения
 	wg       *wgname.WgName  // Объект группового ожидания
-	Slog_    types.ISlog     // Двойной логер
+	Slog_    types.ИСлог     // Двойной логер
 }
 
 // NewMockKernel -- возвращает новый *MockKernel
@@ -35,8 +35,8 @@ func NewMockKernel() types.ИЯдро {
 	return сам
 }
 
-// Store -- возвращает хранилище данных
-func (сам *MockKernel) Store() types.ИХранилище {
+// Хранилище -- возвращает хранилище данных
+func (сам *MockKernel) Хранилище() types.ИХранилище {
 	return nil
 }
 
@@ -45,8 +45,8 @@ func (сам *MockKernel) Wg() types.IWgName {
 	return сам.wg
 }
 
-// CtxApp -- возвращает глобальный контекст приложения
-func (сам *MockKernel) CtxApp() context.Context {
+// Контекст -- возвращает глобальный контекст приложения
+func (сам *MockKernel) Контекст() context.Context {
 	return сам.ctxApp
 }
 
@@ -55,13 +55,13 @@ func (сам *MockKernel) Done() <-chan struct{} {
 	return сам.ctxApp.Done()
 }
 
-// CancelApp -- отменяет глобальный контекст приложения
-func (сам *MockKernel) CancelApp() {
+// Отменить -- отменяет глобальный контекст приложения
+func (сам *MockKernel) Отменить() {
 	// fmt._rintf("MockKernel.CancelApp()\n")
 	сам.fnCancel()
 }
 
-// Slog -- возвращает хранимый логгер
-func (сам *MockKernel) Slog() types.ISlog {
+// Слог -- возвращает хранимый логгер
+func (сам *MockKernel) Слог() types.ИСлог {
 	return сам.Slog_
 }

pkg/mock/mockkernel/mockkernel_test.go

@@ -38,16 +38,16 @@ func (сам *tester) create() {
 	if wg := сам.kern.Wg(); wg == nil {
 		сам.t.Errorf("create(): wg==nil\n")
 	}
-	if ctx := сам.kern.CtxApp(); ctx == nil {
+	if ctx := сам.kern.Контекст(); ctx == nil {
 		сам.t.Errorf("create(): ctx==nil\n")
 	}
 	ядро := сам.kern.(*MockKernel)
-	ядро.Slog_, сам.err = slog.NewSlog(сам.kern)
+	ядро.Slog_, сам.err = slog.НовСлог(сам.kern)
 	if сам.err != nil {
 		сам.t.Errorf("create(): in create ISlog, err=\n\t%v", сам.err)
 	}
-	if slog := сам.kern.Slog(); slog == nil {
+	if slog := сам.kern.Слог(); slog == nil {
 		сам.t.Errorf("create(): slog==nil")
 	}
-	сам.kern.CancelApp()
+	сам.kern.Отменить()
 }

pkg/types/ikernel.go

@@ -20,14 +20,14 @@ type IWgName interface {
 type ИЯдро interface {
 	// Done -- возвращает канал отмены контекста приложения
 	Done() <-chan struct{}
-	// CancelApp -- функция тмены глобального контекста ядра
-	CancelApp()
+	// Отменить -- функция отмены глобального контекста ядра
+	Отменить()
 	// Wg -- возвращает групповой объект ожидания
 	Wg() IWgName
-	// Slog -- возвращает логгер
-	Slog() ISlog
-	// CtxApp -- возвращает контекст приложения
-	CtxApp() context.Context
-	// Store -- возвращает хранилище
-	Store() ИХранилище
+	// Слог -- возвращает логгер
+	Слог() ИСлог
+	// Контекст -- возвращает контекст приложения
+	Контекст() context.Context
+	// Хранилище -- возвращает хранилище
+	Хранилище() ИХранилище
 }

pkg/types/iserver.go

@@ -7,8 +7,6 @@ package types
 // ИСервер -- интерфейс для приложения
 type ИСервер interface {
 	ИЯдро
-	// Store -- хранилище приложения
-	Store() ИХранилище
 	// Run -- запускает приложение в работу
 	Run() error
 	// ServBots -- словарь имеющихся ботов

pkg/types/islog.go

@@ -4,14 +4,14 @@ package types
 	Интерфейс логирования
 */
 
-// ISlog -- интерфейс к логирования
-type ISlog interface {
-	// Debugf -- отладочный вывод
-	Debugf(str string, lst ...interface{})
-	// Infof -- информационный дежурный вывод
-	Infof(str string, lst ...interface{})
-	// Warnf -- вывод предупреждения
-	Warnf(str string, lst ...interface{})
-	// Errorf -- вывод ошибки
-	Errorf(str string, lst ...interface{})
+// ИСлог -- интерфейс к логирования
+type ИСлог interface {
+	// Отладка -- отладочный вывод
+	Отладка(str string, lst ...interface{})
+	// Инфо -- информационный дежурный вывод
+	Инфо(str string, lst ...interface{})
+	// Внимание -- вывод предупреждения
+	Внимание(str string, lst ...interface{})
+	// Ошибка -- вывод ошибки
+	Ошибка(str string, lst ...interface{})
 }

server/serv_bots/dict_warbot/dict_warbot.go

@@ -33,7 +33,7 @@ func NewDictWarBot(server types.ИСервер) (*DictWarBot, error) {
 	log.Printf("NewDictWarBot()\n")
 	сам := &DictWarBot{
 		server: server,
-		store:  server.Store(),
+		store:  server.Хранилище(),
 		dict:   map[alias.БотНомер]types.ИБот{},
 	}
 	if err := сам.load(); err != nil {
@@ -81,7 +81,7 @@ func (сам *DictWarBot) save() {
 	strNumber = strNumber[:len(strNumber)-1]
 	err := сам.store.Уст(strBotList, []byte(strNumber))
 	if err != nil {
-		сам.server.CancelApp()
+		сам.server.Отменить()
 	}
 }
 

server/serv_bots/serv_bots.go

@@ -24,7 +24,7 @@ func НовБотоФерма(серв types.ИСервер) (*БотоФерм
 	}
 	сам := &БотоФерма{
 		серв: серв,
-		хран: серв.Store(),
+		хран: серв.Хранилище(),
 	}
 	var ош error
 	сам.dictBot, ош = dict_warbot.NewDictWarBot(серв)

server/serv_bots/warbot/angar/angar.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"sync"
 	"time"
+	"log"
 
 	"strconv"
 	"strings"
@@ -21,8 +22,6 @@ import (
 	"wartank/server/serv_bots/warbot/angar/netstat"
 	"wartank/server/serv_bots/warbot/angar/tank_params"
 	"wartank/server/serv_bots/warbot/tank/tankstat/static_param"
-
-	"github.com/sirupsen/logrus"
 )
 
 /*
@@ -32,6 +31,7 @@ import (
 // Ангар -- ангар для танка
 type Ангар struct {
 	*section.Секция
+	слог       types.ИСлог
 	сеть       types.ИСценаСеть
 	топливоБой *fuel_attack.ТопливоБой
 
@@ -93,6 +93,7 @@ func НовАнгар(bot types.ИБот) (*Ангар, error) {
 	}
 	сам := &Ангар{
 		Секция:        section,
+		слог: bot.Сервер().Слог(),
 		бот:           bot,
 		золото:        золото,
 		уровень:       уровень,
@@ -165,7 +166,12 @@ func НовАнгар(bot types.ИБот) (*Ангар, error) {
 // Обновить -- обновить ангар принудиельно
 func (сам *Ангар) Обновить() {
 	сам.РесурсыОбновить()
-	сам.сетьТанкСтат.Update()
+	ош:=сам.сетьТанкСтат.Update()
+	if ош!=nil{
+		сам.слог.Инфо("НовАнгар(): при обновлении статистики, ош=\n\t%w\n", ош)
+		сам.бот.Сервер().Отменить()
+		return
+	}
 	сам.конвой.Обновить()
 	сам.топливо.Обновить()
 }
@@ -199,13 +205,18 @@ func (сам *Ангар) Пуск() error {
 		// сам.конвойПроверить()
 		if err := сам.Секция.ОбратВремяУст("01:00"); err != nil {
 			сам.Отмена()
-			logrus.WithError(err).Errorln("Ангар.Run(): in update ICountTime")
+			log.Printf("Ангар.Run(): in update ICountTime, err=\n\t%v\n", err)
 			return false
 		}
 		return true
 	}
 	go func() {
-		сам.Секция.ОбратВремяУст("01")
+		ош:=сам.Секция.ОбратВремяУст("01")
+		if ош!=nil{
+			сам.слог.Ошибка("Ангар.Run(): in update ICountTime, ош=\n\t%w\n", ош)
+			сам.бот.Сервер().Отменить()
+			return
+		}
 		for {
 			select {
 			case <-сам.бот.Кнт().Done(): // Отмена контекста

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

@@ -25,6 +25,7 @@ const (
 // Оружейная -- объект оружейной на базе
 type Оружейная struct {
 	*section.Секция
+	слог         types.ИСлог
 	бот          types.ИБот
 	база         types.ИБаза
 	сеть         *arsenalnet.ArsenalNet
@@ -75,6 +76,7 @@ func НовОружейная(база types.ИБаза) (*Оружейная, e
 	сам := &Оружейная{
 		Секция:     section,
 		бот:        база.Бот(),
+		слог:       база.Бот().Сервер().Слог(),
 		база:       база,
 		фугас:      фугас,
 		бронебойка: бронейбойки,
@@ -134,7 +136,11 @@ func (сам *Оружейная) пуск() {
 		if сам.уровеньОбновить() {
 			return
 		}
-		сам.СтатаОбновить()
+		ош := сам.СтатаОбновить()
+		if ош != nil {
+			сам.слог.Ошибка("ArsenalNet.Run(): in update stat, err=\n\t%w", ош)
+			return
+		}
 		сам.забрать()
 		сам.сделать()
 	}
@@ -518,7 +524,7 @@ func (сам *Оружейная) сделать() bool {
 		фугасКол  = сам.Фугасы().Получ()
 		кумульКол = сам.Кумулятивы().Получ()
 		ббКол     = сам.Бронебойки().Получ()
-		снарядТип = ""
+		снарядТип string
 	)
 	if ремкаКол < 70 { // Контроль ремки по времени суток и минимальному количеству ремок
 		for !сам.сделатьРемку() {
@@ -629,7 +635,7 @@ func (сам *Оружейная) сделатьКумули() bool {
 func (сам *Оружейная) сделатьФугасы() bool {
 	var (
 		lstArsenal = сам.СписПолучить()
-		стрВых     = ""
+		стрВых     string
 		еслиНадено bool
 		инд        int
 	)
@@ -666,7 +672,7 @@ func (сам *Оружейная) сделатьФугасы() bool {
 func (сам *Оружейная) сделатьРемку() bool {
 	// _mt.Println("\tArsenalNet.makeRemka()")
 	var (
-		стрВых      = ""
+		стрВых      string
 		еслиНайдено bool
 		инд         int
 	)

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

@@ -35,6 +35,7 @@ const (
 // База -- объект базы
 type База struct {
 	*section.Секция
+	бот          types.ИБот
 	сеть         *basenet.BaseNet
 	арсенал      *arsenal.Оружейная
 	банк         *bank.Банк
@@ -56,6 +57,7 @@ func НовБаза(ангар types.ИАнгар) (*База, error) {
 	log.Printf("НовБаза(): %q\n", section.Бот().Имя())
 	сам := &База{
 		Секция: section,
+		бот:    ангар.Бот(),
 	}
 	{ // База в сети
 		сам.сеть, ош = basenet.NewBaseNet(сам)
@@ -193,7 +195,11 @@ func (сам *База) setCountDown() {
 	if timeCount > "00:10:00" {
 		сам.времОстат = 600
 	}
-	сам.Секция.ОбратВремяУст(alias.Время(timeCount))
+	ош := сам.Секция.ОбратВремяУст(alias.Время(timeCount))
+	if ош != nil {
+		log.Printf("ERRO Base.setCountDown(): при установке обратного отсчёта времени, err=\n\t%v\n", ош)
+		сам.Отмена()
+	}
 }
 
 // Арсенал -- возвращает объект арсенала
@@ -661,7 +667,11 @@ func (сам *База) checkBankProduct() {
 		return
 	}
 	сам.банк.UpdateLst()
-	сам.банк.ОбратВремяУст("01:00")
+	ош := сам.банк.ОбратВремяУст("01:00")
+	if ош != nil {
+		log.Printf("ERRO Base.checkBankProduct(): при установке обратного времени ожидания банка, err=\n\t%v\n", ош)
+		сам.бот.Сервер().Отменить()
+	}
 }
 
 // Проверка получения серебра из банка

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

@@ -130,7 +130,7 @@ func (сам *СкладТоплива) ускорениеПровер() {
 	// <span class="green2">Склад топлива -
 	var (
 		еслиНайти = false
-		стр       = ""
+		стр       string
 	)
 	for _, стр = range списСтр {
 		if strings.Contains(стр, `<span class="green2">Склад топлива - `) {

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

@@ -1,3 +1,4 @@
+// package market -- объект рынка
 package market
 
 import (
@@ -14,10 +15,6 @@ import (
 	"wartank/server/serv_bots/warbot/tank/tankstat/static_param"
 )
 
-/*
-	Объект рынка
-*/
-
 // Рынок -- объект рынка
 type Рынок struct {
 	*section.Секция
@@ -88,7 +85,7 @@ func (сам *Рынок) ускорениеПровер() {
 	// <span class="green2">Склад топлива -
 	var (
 		еслиНайти = false
-		стр       = ""
+		стр       string
 	)
 	for _, стр = range списСтр {
 		if strings.Contains(стр, `<span class="green2">Склад топлива - `) {

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

@@ -99,7 +99,12 @@ const (
 
 // выполняет опрос полигона базы.
 func (сам *Полигон) пуск() {
-	сам.ОбратВремяУст("02")
+	ош := сам.ОбратВремяУст("02")
+	if ош != nil {
+		log.Printf("Полигон(): при установке времени обратного отсчета, ош=\n\t%v\n", ош)
+		сам.бот.Сервер().Отменить()
+		return
+	}
 	фнРабота := func() {
 		defer func() {
 			for сам.ВремяОстат().ПолучМилСек() > 0 {
@@ -113,7 +118,12 @@ func (сам *Полигон) пуск() {
 		сам.построитьПровер()
 		сам.проверитьУскорение()
 		if сам.продуктСейчас.Получ() == стрАпгрейд {
-			сам.ВремяОстат().Уст("00:10:00")
+			ош := сам.ВремяОстат().Уст("00:10:00")
+			if ош != nil {
+				log.Printf("Полигон(): при установке времени обратного отсчета, ош=\n\t%v\n", ош)
+				сам.бот.Сервер().Отменить()
+				return
+			}
 		}
 		счёт := 5
 		for счёт > 0 {
@@ -309,7 +319,12 @@ func (сам *Полигон) времяОбнов() {
 	)
 	defer func() {
 		if !isSet {
-			сам.ОбратВремяУст("05")
+			ош := сам.ОбратВремяУст("05")
+			if ош != nil {
+				log.Printf("Полигон.времяОбнов(): при установке обратного времени ожидания полигона, ош=\n\t%v\n", ош)
+				сам.бот.Сервер().Отменить()
+				return
+			}
 		}
 	}()
 	for _, lastTime := range lstPolygon {

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

@@ -2,12 +2,10 @@ package manevr
 
 import (
 	"fmt"
-	// "log"
+	"log"
 	"strings"
 	"time"
 
-	"github.com/sirupsen/logrus"
-
 	"wartank/server/serv_bots/warbot/angar/battle/battle_worker/battleon/health/repairtime"
 	"wartank/server/serv_bots/warbot/angar/battle/battle_worker/battleon/manevr/ismanevr"
 
@@ -97,7 +95,7 @@ func (сам *Манёвр) времяМанёврНайти() {
 			_ = сам.времяЖдать.Set("0")
 			return
 		}
-		logrus.WithField("strOut", strOut).Warn("Манёвр.времяМанёврНайти(): ошибка в поиске времени манёвра")
+		log.Printf("Манёвр.времяМанёврНайти(): не найдено время манёвра")
 		сам.Отменить()
 		return
 	}

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

@@ -35,7 +35,7 @@ func (сам *ShotTime) Dec5() {
 	сам.block.Lock()
 	defer сам.block.Unlock()
 	сам.val -= 5
-	if сам.val < 0 {
+	if сам.val > 500_000 {
 		сам.val = 0
 	}
 }
@@ -45,7 +45,7 @@ func (сам *ShotTime) Dec30() {
 	сам.block.Lock()
 	defer сам.block.Unlock()
 	сам.val -= 30
-	if сам.val < 0 {
+	if сам.val > 500_000 {
 		сам.val = 0
 	}
 }
@@ -68,7 +68,7 @@ func (сам *ShotTime) IsZero() bool {
 func (сам *ShotTime) Set(val alias.МилСек) {
 	сам.block.Lock()
 	defer сам.block.Unlock()
-	if val < 0 {
+	if val > 500_000 {
 		logrus.WithField("val", val).Error("ShotTime.Set(): отрицательное значение")
 		return
 	}

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

@@ -7,8 +7,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/sirupsen/logrus"
-
 	"wartank/pkg/alias"
 	"wartank/pkg/section"
 	"wartank/pkg/types"
@@ -139,8 +137,13 @@ func (сам *Конвой) Обновить() {
 func (сам *Конвой) обновитьВремя() {
 	// Время подходит надо обновляться
 	if err := сам.net.Обновить(); err != nil {
-		logrus.WithError(err).Error("Конвой.обновитьВремя(): при выполнении GET-команды обновления")
-		сам.ОбратВремяУст("20")
+		log.Printf("Конвой.обновитьВремя(): при выполнении GET-команды обновления, err=\n\t%v\n", err)
+		ош:=сам.ОбратВремяУст("20")
+		if ош!=nil {
+			log.Printf("Конвой.обновитьВремя(): при обновлении времени, ош=\n\t%v\n", ош)
+			сам.бот.Сервер().Отменить()
+			return
+		}
 		return
 	}
 	// Найти строку с упоминанием оставшегося времени конвоя

server/serv_bots/warbot/angar/death_match/death_register/death_register.go

@@ -44,7 +44,7 @@ func (сам *СхваткаРегистрация) Зарегистрирова
 	// https://wartank.ru/dm?{count}-1.ILinkListener-currentOverview-apply
 	фнРегис := func() []string {
 		стрСсылка := "https://wartank.ru/dm?0-1.ILinkListener-currentOverview-apply"
-		стрКонтроль := "https://wartank.ru/dm?0-1.ILinkListener-currentOverview-apply"
+		стрКонтроль := "" // "https://wartank.ru/dm?0-1.ILinkListener-currentOverview-apply"
 		for {
 			time.Sleep(time.Second * 1)
 			лстСражение, err := сам.сеть.Get(стрСсылка)

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

@@ -5,7 +5,7 @@ import (
 	"fmt"
 
 	// "log"
-	"strconv"
+	// "strconv"
 	"strings"
 	"time"
 
@@ -32,9 +32,9 @@ type Health struct {
 	isEnd                       *safe_bool.БезопБул    // Ссылка на признак конца сражения
 	login                       string                 // Для поиска контрольных строк
 	chTick                      chan int               // Канал для ровной отправки тиков
-	deltaOld                    int                    // Старая дельта потери здоровья
-	countLow                    int
-	ctxBattle                   context.Context // Конекст сражения
+	// deltaOld                    int                    // Старая дельта потери здоровья
+	// countLow                    int
+	ctxBattle context.Context // Конекст сражения
 }
 
 // NewHealth -- возвращает новый *Health
@@ -108,9 +108,9 @@ func (сам *Health) run() {
 			сам.isEnd.Уст()
 			return
 		case <-сам.chTick:
-			if err := сам.findHealth(); err != nil { // Найти свой здоровье
-				// log._rintf("ERRO Health.run(): при попытке найти здоровье, err=\n\t%v\n", err)
-			}
+			// if err := сам.findHealth(); err != nil { // Найти свой здоровье
+			// 	// log._rintf("ERRO Health.run(): при попытке найти здоровье, err=\n\t%v\n", err)
+			// }
 			сам.findRepairTime()
 			if сам.ВыстрелБлок().Получ() {
 				if сам.isRepair.Получ() {
@@ -155,9 +155,9 @@ func (сам *Health) findRepairTime() {
 		if сам.repairTime.IsReady() {
 			return
 		}
-		if сам.repairTime.IsChange() {
-			// log._rintf("INFO Health.findRepair(): до ремки=%v\n", сам.repairTime.Get())
-		}
+		// if сам.repairTime.IsChange() {
+		// log._rintf("INFO Health.findRepair(): до ремки=%v\n", сам.repairTime.Get())
+		// }
 	}()
 	if сам.repairTime.IsReady() {
 		return
@@ -191,12 +191,12 @@ func (сам *Health) findRepairTime() {
 		сам.CancelBattle()
 		return
 	}
-	strTime := lstTime[1]
-	lstTime = strings.Split(strTime, ` секунд</span></span></a>`)
-	strTime = lstTime[0]
-	if err := сам.repairTime.Set(strTime); err != nil {
-		// log._rintf("ERRO Health.findRepair(): при установке времени восстановления ремки, err=\n\t%v\n", err)
-	}
+	// strTime := lstTime[1]
+	// lstTime = strings.Split(strTime, ` секунд</span></span></a>`)
+	// strTime = lstTime[0]
+	// if err := сам.repairTime.Set(strTime); err != nil {
+	// 	 log._rintf("ERRO Health.findRepair(): при установке времени восстановления ремки, err=\n\t%v\n", err)
+	// }
 }
 
 // Восстановливает здоровье (~)
@@ -242,117 +242,117 @@ func (сам *Health) repair() {
 }
 
 // Ищет своё здоровье (~)
-func (сам *Health) findHealth() error {
-	var (
-		ind         int
-		strOut      string
-		еслиНайдено bool
-		lstBattle   = сам.СписПолучить()
-	)
-	if len(lstBattle) == 0 { // Принудительно обновим сражение
-		if err := сам.Сеть().Обновить(); err != nil {
-			сам.isEnd.Уст()
-			сам.fnCancel()
-			return fmt.Errorf("Health.findHealth(): после принудительного обновления lsBattleOn, err=\n\t%w", err)
-		}
-	}
-	for ind, strOut = range lstBattle {
-		if strings.Contains(strOut, `alt="`+сам.login+`"`) {
-			еслиНайдено = true
-			break
-		}
-	}
-	if !еслиНайдено { // Свой танк не найден
-		сам.isEnd.Уст()
-		сам.fnCancel()
-		return fmt.Errorf("Health.findHealth(): своё здоровье не найдено")
-	}
-	// Свой танк найден, ищем здоровье
-	ind += 11
-	strOut = lstBattle[ind]
-	lstHealth := strings.Split(strOut, `<div class="value-block lh1"><span><span>`)
-	strHealth := lstHealth[1]
-	lstHealth = strings.Split(strHealth, `</span></span></div>`)
-	strHealth = lstHealth[0]
-	iHealth, err := strconv.Atoi(strHealth)
-	if err != nil {
-		сам.isEnd.Уст()
-		сам.CancelBattle()
-		return fmt.Errorf("Health.findHealth(): здоровье(%v) не число, err=%w", strHealth, err)
-	}
-	сам.setHealth(iHealth)
-	return nil
-}
+// func (сам *Health) findHealth() error {
+// 	var (
+// 		ind         int
+// 		strOut      string
+// 		еслиНайдено bool
+// 		lstBattle   = сам.СписПолучить()
+// 	)
+// 	if len(lstBattle) == 0 { // Принудительно обновим сражение
+// 		if err := сам.Сеть().Обновить(); err != nil {
+// 			сам.isEnd.Уст()
+// 			сам.fnCancel()
+// 			return fmt.Errorf("Health.findHealth(): после принудительного обновления lsBattleOn, err=\n\t%w", err)
+// 		}
+// 	}
+// 	for ind, strOut = range lstBattle {
+// 		if strings.Contains(strOut, `alt="`+сам.login+`"`) {
+// 			еслиНайдено = true
+// 			break
+// 		}
+// 	}
+// 	if !еслиНайдено { // Свой танк не найден
+// 		сам.isEnd.Уст()
+// 		сам.fnCancel()
+// 		return fmt.Errorf("Health.findHealth(): своё здоровье не найдено")
+// 	}
+// 	// Свой танк найден, ищем здоровье
+// 	ind += 11
+// 	strOut = lstBattle[ind]
+// 	lstHealth := strings.Split(strOut, `<div class="value-block lh1"><span><span>`)
+// 	strHealth := lstHealth[1]
+// 	lstHealth = strings.Split(strHealth, `</span></span></div>`)
+// 	strHealth = lstHealth[0]
+// 	iHealth, err := strconv.Atoi(strHealth)
+// 	if err != nil {
+// 		сам.isEnd.Уст()
+// 		сам.CancelBattle()
+// 		return fmt.Errorf("Health.findHealth(): здоровье(%v) не число, err=%w", strHealth, err)
+// 	}
+// 	сам.setHealth(iHealth)
+// 	return nil
+// }
 
 // setHealth -- устанавливает текущее здоровье
-func (сам *Health) setHealth(val int) {
-	if val < 0 {
-		// log._rintf("WARN Health.setHealth(): кривое значение здоровья танка(%v)\n", val)
-		val = 0
-	}
+// func (сам *Health) setHealth(val int) {
+// 	if val < 0 {
+// 		// log._rintf("WARN Health.setHealth(): кривое значение здоровья танка(%v)\n", val)
+// 		val = 0
+// 	}
 
-	if val > сам.full.Get() {
-		// log._rintf("WARN Health.setHealth(): кривое текущее здоровье, %v/%v\n", val, сам.full.Get())
-		сам.full.Set(val)
-		сам.temp.Set(val)
-		сам.deltaOld = 0
-		сам.ВыстрелБлок().Сброс()
-		сам.isRepair.Сброс()
-		return
-	}
+// 	if val > сам.full.Get() {
+// 		// log._rintf("WARN Health.setHealth(): кривое текущее здоровье, %v/%v\n", val, сам.full.Get())
+// 		сам.full.Set(val)
+// 		сам.temp.Set(val)
+// 		// сам.deltaOld = 0
+// 		сам.ВыстрелБлок().Сброс()
+// 		сам.isRepair.Сброс()
+// 		return
+// 	}
 
-	delta := сам.temp.Get() - val
-	if delta > 0 { // Дельта будет больше нуля, если только
-		if delta != сам.deltaOld {
-			// log._rintf("INFO Health.setHealth(): потеря здоровья=%v/%v\n", -delta, val)
-			сам.deltaOld = delta
-			сам.temp.Set(val)
-		}
-	}
+// 	delta := сам.temp.Get() - val
+// 	// if delta > 0 { // Дельта будет больше нуля, если только
+// 	// 	if delta != сам.deltaOld {
+// 	// 		// log._rintf("INFO Health.setHealth(): потеря здоровья=%v/%v\n", -delta, val)
+// 	// 		сам.deltaOld = delta
+// 	// 		сам.temp.Set(val)
+// 	// 	}
+// 	// }
 
-	switch {
-	case сам.isEnd.Получ():
-		сам.temp.Set(0)
-		сам.isEnd.Уст()
-		сам.CancelBattle()
-		return
-	case val == 0:
-		сам.temp.Set(0)
-		сам.isEnd.Уст()
-		сам.CancelBattle()
-		return
-	case val <= 500: // Запретить стрельбу
-		сам.ВыстрелБлок().Уст() // Установить запрет стрельбы пока слабое здоровье
-		сам.isRepair.Уст()
-		// log._rintf("WARN Health.setHealth(): низкий уровень здоровья(%v)\n", val)
-		сам.Манёвр()
-	case val > 500: // Разрешить стрельбы
-		сам.ВыстрелБлок().Сброс()
-		сам.isRepair.Сброс()
-		if delta > сам.full.Get()*4/10 { // Проверить на критичность падения здоровья на 40%
-			// log._rintf("WARN Health.setHealth(): большая разовая потеря здоровья(%v)\n", delta)
-			сам.Манёвр()
-			сам.isRepair.Уст()
-			return
-		}
-	}
+// 	switch {
+// 	case сам.isEnd.Получ():
+// 		сам.temp.Set(0)
+// 		сам.isEnd.Уст()
+// 		сам.CancelBattle()
+// 		return
+// 	case val == 0:
+// 		сам.temp.Set(0)
+// 		сам.isEnd.Уст()
+// 		сам.CancelBattle()
+// 		return
+// 	case val <= 500: // Запретить стрельбу
+// 		сам.ВыстрелБлок().Уст() // Установить запрет стрельбы пока слабое здоровье
+// 		сам.isRepair.Уст()
+// 		// log._rintf("WARN Health.setHealth(): низкий уровень здоровья(%v)\n", val)
+// 		сам.Манёвр()
+// 	case val > 500: // Разрешить стрельбы
+// 		сам.ВыстрелБлок().Сброс()
+// 		сам.isRepair.Сброс()
+// 		if delta > сам.full.Get()*4/10 { // Проверить на критичность падения здоровья на 40%
+// 			// log._rintf("WARN Health.setHealth(): большая разовая потеря здоровья(%v)\n", delta)
+// 			сам.Манёвр()
+// 			сам.isRepair.Уст()
+// 			return
+// 		}
+// 	}
 
-	isMask := сам.ВыстрелБлок().Получ()
-	switch isMask {
-	case true:
-		сам.countLow++
-		if сам.countLow >= 200 {
-			сам.isEnd.Уст()
-			сам.CancelBattle()
-			return
-		}
-	default:
-		сам.countLow = 0
-	}
-	if val == сам.full.Get() {
-		сам.temp.Set(val)
-		сам.isRepair.Сброс()
-		сам.ВыстрелБлок().Сброс()
-		сам.countLow = 0
-	}
-}
+// 	isMask := сам.ВыстрелБлок().Получ()
+// 	switch isMask {
+// 	case true:
+// 		// сам.countLow++
+// 		// if сам.countLow >= 200 {
+// 		// 	сам.isEnd.Уст()
+// 		// 	сам.CancelBattle()
+// 		// 	return
+// 		// }
+// 	default:
+// 		// сам.countLow = 0
+// 	}
+// 	if val == сам.full.Get() {
+// 		сам.temp.Set(val)
+// 		сам.isRepair.Сброс()
+// 		сам.ВыстрелБлок().Сброс()
+// 		// сам.countLow = 0
+// 	}
+// }

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

@@ -35,7 +35,7 @@ func (сам *ShotTime) Dec5() {
 	сам.block.Lock()
 	defer сам.block.Unlock()
 	сам.val -= 5
-	if сам.val < 0 {
+	if сам.val > 500_000 {
 		сам.val = 0
 	}
 }
@@ -45,7 +45,7 @@ func (сам *ShotTime) Dec30() {
 	сам.block.Lock()
 	defer сам.block.Unlock()
 	сам.val -= 30
-	if сам.val < 0 {
+	if сам.val > 500_000 {
 		сам.val = 0
 	}
 }
@@ -68,8 +68,8 @@ func (сам *ShotTime) IsZero() bool {
 func (сам *ShotTime) Set(val alias.МилСек) {
 	сам.block.Lock()
 	defer сам.block.Unlock()
-	if val < 0 {
-		logrus.WithField("val", val).Error("ShotTime.Set(): отрицательное значение")
+	if val > 500_000 {
+		logrus.WithField("val", val).Error("ShotTime.Set(): слишком большое значение")
 		return
 	}
 	сам.val = val

server/serv_bots/warbot/angar/netstat/netstat.go

@@ -286,7 +286,7 @@ func (сам *NetStat) findOnline() (err error) {
 	// Выделить число игроков онлайн
 	lstAngar = strings.Split(strOut, `<span class="yellow1">`)
 	if len(lstAngar) <= 1 {
-		сам.server.CancelApp()
+		сам.server.Отменить()
 		return
 	}
 	strOnline := lstAngar[1]

server/serv_bots/warbot/angar/tank_params/tank_params.go

@@ -36,7 +36,12 @@ func (сам *ТанкПараметры) Пуск() {
 // Запукает в работу в отдельном потоке
 func (сам *ТанкПараметры) пуск() {
 	time.Sleep(time.Second * 4)
-	сам.номерПолуч()
+	ош := сам.номерПолуч()
+	if ош != nil {
+		log.Printf("ТанкПараметры.пуск(): при получении параметров танка, ош=\n\t%v\n", ош)
+		сам.бот.Сервер().Отменить()
+		return
+	}
 	for {
 		select {
 		case <-сам.бот.Кнт().Done():

server/serv_bots/warbot/warbot.go

@@ -44,7 +44,7 @@ func ЗагрузитьВарБот(сервер types.ИСервер, номе
 	}
 	стрНомер := fmt.Sprint(номер)
 	log.Printf("ЗагрузитьВарБот(): номер=%q\n", стрНомер)
-	store := сервер.Store()
+	store := сервер.Хранилище()
 	binData, err := store.Получ("/bots/" + стрНомер)
 	if err != nil {
 		if !strings.Contains(err.Error(), "not found") {
@@ -119,10 +119,10 @@ func создатьЯдроВарБот(серв types.ИСервер, конф
 	if ош != nil {
 		return nil, fmt.Errorf("NewWarBot(): при создании параметров танка, ош=\n\t%w", ош)
 	}
-	ctx, fnCancel := context.WithCancel(серв.CtxApp())
+	ctx, fnCancel := context.WithCancel(серв.Контекст())
 	сам := &ВарБот{
 		сервер:         серв,
-		store:          серв.Store(),
+		store:          серв.Хранилище(),
 		танк:           танк,
 		еслиРаботает:   safe_bool.НовБезопБул(),
 		еслиАвтозапуск: safe_bool.НовБезопБул(),

server/serv_web/serv_web.go

@@ -130,7 +130,7 @@ func (сам *СервВеб) Пуск() {
 		ош := сам.файбер.Listen(":" + сам.порт)
 		if ош != nil {
 			log.Printf("СервВеб.Пуск(): при работе веб-сервера, ош=\n\t%v\n", ош)
-			сам.серв.CancelApp()
+			сам.серв.Отменить()
 		}
 	}
 	stage := os.Getenv("STAGE")

server/server_stat/server_stat.go

@@ -42,7 +42,7 @@ func НовСерверСтат(серв types.ИСервер) (*СерверС
 
 // Загружает статистику сервера
 func (сам *СерверСтат) загр() error {
-	бинДанные, ош := сам.серв.Store().Получ("server_stat")
+	бинДанные, ош := сам.серв.Хранилище().Получ("server_stat")
 	if ош != nil {
 		if strings.Contains(ош.Error(), "not found") {
 			return nil
@@ -64,7 +64,7 @@ func (сам *СерверСтат) пуск() {
 		сам.ВремяСессия_ += time.Second
 		if ош := сам.сохр(); ош != nil {
 			fmt.Printf("СерверСтат.пуск(): при сохранении статистики в хранилище, ош=\n\t%v\n", ош)
-			сам.серв.CancelApp()
+			сам.серв.Отменить()
 			return
 		}
 		time.Sleep(time.Second)
@@ -85,7 +85,7 @@ func (сам *СерверСтат) сохр() error {
 	if ош != nil {
 		return fmt.Errorf("СерверСтат.сохр(): при кодировании статистики в JSON, ош=\n\t%w", ош)
 	}
-	ош = сам.серв.Store().Уст("server_stat", бинДанные)
+	ош = сам.серв.Хранилище().Уст("server_stat", бинДанные)
 	if ош != nil {
 		return fmt.Errorf("СерверСтат.сохр(): при сохранении статистики в хранилище, ош=\n\t%w", ош)
 	}