d03 Исправления, русификация

pkg/mock/mock_zone/mock_zone.go

@@ -2,6 +2,5 @@
 package mock_zone
 
 // МокОбласть -- мок-область зоны игры
-type МокОбласть struct{
-
-}
+type МокОбласть struct {
+}

pkg/types/itankstat.go

@@ -16,6 +16,8 @@ type ИТанкСтат interface {
 	Прочность() ИСтатПарам
 	// Мощь -- возвращает мощность танка
 	Мощь() ИСтатПарам
-	// ПарамФорсаж -- устанавливает форсирование параметра
-	ПарамФорсаж() ИСтатПарам
+	// Форсаж -- устанавливает форсирование параметра
+	Форсаж() ИСтатПарам
+	// ФорсажОбнов -- обновляет параметры форсажа
+	ФорсажОбнов(имя string, парам int)
 }

server/gui/win_main/win_main.go

@@ -271,7 +271,7 @@ func (sf *WinMain) showStat() {
 			sf.lblHard.Refresh()
 			sf.lblPower.Text = fmt.Sprint(bot.Танк().ТанкСтат().Мощь().Получ())
 			sf.lblPower.Refresh()
-			strForce := fmt.Sprintf("%v (+%v)", bot.Танк().ТанкСтат().ПарамФорсаж().Имя(), bot.Танк().ТанкСтат().ПарамФорсаж().Получ())
+			strForce := fmt.Sprintf("%v (+%v)", bot.Танк().ТанкСтат().Форсаж().Имя(), bot.Танк().ТанкСтат().Форсаж().Получ())
 			sf.lblForce.SetText(strForce)
 		}
 		{ // Вкладка базы
@@ -281,7 +281,7 @@ func (sf *WinMain) showStat() {
 			polyTime := bot.Ангар().База().Полигон().ВремяОпрос().Стр()
 			sf.lblPolygonTime.SetText("Время: " + polyTime)
 			// polyMode := bot.Angar().Base().Polygon().ModeCurrent().Work()
-			strForce := fmt.Sprintf("%v (+%v)", bot.Танк().ТанкСтат().ПарамФорсаж().Имя(), bot.Танк().ТанкСтат().ПарамФорсаж().Получ())
+			strForce := fmt.Sprintf("%v (+%v)", bot.Танк().ТанкСтат().Форсаж().Имя(), bot.Танк().ТанкСтат().Форсаж().Получ())
 			sf.lblPolygonMode.SetText("Режим: " + strForce)
 
 			mineTime := bot.Ангар().База().Шахта().ВремяОпрос().Стр()

server/serv_bots/dict_warbot/dict_warbot.go

@@ -101,7 +101,7 @@ func (sf *DictWarBot) load() error {
 		if isOk {
 			continue
 		}
-		bot, err := warbot.LoadWarBot(sf.server, name)
+		bot, err := warbot.ЗагрузитьВарБот(sf.server, name)
 		if err != nil {
 			return fmt.Errorf("ServBots.load(): in create bot %q, err=\n\t%w", name, err)
 		}

server/serv_bots/serv_bots.go

@@ -67,7 +67,7 @@ func (sf *ServBots) NewBot(login, pass string) error {
 		}
 	}
 	{ // Нет такого бота, надо его создать
-		bot, err := warbot.NewWarBot(sf.server, login, pass)
+		bot, err := warbot.НовВарБот(sf.server, login, pass)
 		if err != nil {
 			return fmt.Errorf("ServBots.NewBot(): in create bot %q, err=\n\t%w", login, err)
 		}

server/serv_bots/warbot/angar/angar.go

@@ -30,63 +30,63 @@ import (
 // Angar -- ангар для танка
 type Angar struct {
 	*section.Section
-	net     *angarnet.AngarNet
+	сеть    *angarnet.AngarNet
 	netKill *angar_attack.AngarAttack
 
-	bot      types.ИБот
-	convoy   *convoy.Convoy
-	battle   *battle.Battle
-	batMas   *batmas.BatMas
-	base     *base.Base
-	missions *missions.Missions
+	бот      types.ИБот
+	конвой   *convoy.Convoy
+	сражение *battle.Battle
+	битва    *batmas.BatMas
+	база     *base.Base
+	миссии   *missions.Missions
 
 	золото        types.ИСтатПарам
 	уровень       types.ИСтатПарам
 	progress      types.ИСтатПарам
-	fuel          *fuel.Fuel
+	топливо       *fuel.Fuel
 	игроковОнлайн types.ИСтатПарам
 
 	сереброВсего types.ИСтатПарам
 	silverOnline types.ИСтатПарам
 
-	stat  *netstat.NetStat
-	block sync.Mutex
+	сетьСтат *netstat.NetStat
+	блок     sync.Mutex
 }
 
-// NewAngar -- возвращает новый *Angar
-func NewAngar(bot types.ИБот) (*Angar, error) {
+// НовАнгар -- возвращает новый *Angar
+func НовАнгар(bot types.ИБот) (*Angar, error) {
 	section, err := section.NewSection(bot, "Ангар", `<title>Ангар</title>`)
 	if err != nil {
-		return nil, fmt.Errorf("NewAngar(): in create ISection, err=\n\t%w", err)
+		return nil, fmt.Errorf("НовАнгар(): in create ISection, err=\n\t%w", err)
 	}
 
 	золото, ош := static_param.НовСтатПарам("gold")
 	if ош != nil {
-		return nil, fmt.Errorf("NewAngar(): при создании статистики золота, ош=\n\t%w", ош)
+		return nil, fmt.Errorf("НовАнгар(): при создании статистики золота, ош=\n\t%w", ош)
 	}
 	уровень, ош := static_param.НовСтатПарам("level")
 	if ош != nil {
-		return nil, fmt.Errorf("NewAngar(): при создании статистики уровня бота, ош=\n\t%w", ош)
+		return nil, fmt.Errorf("НовАнгар(): при создании статистики уровня бота, ош=\n\t%w", ош)
 	}
 	прогресс, ош := static_param.НовСтатПарам("progress")
 	if ош != nil {
-		return nil, fmt.Errorf("NewAngar(): при создании статистики прогресса уровня, ош=\n\t%w", ош)
+		return nil, fmt.Errorf("НовАнгар(): при создании статистики прогресса уровня, ош=\n\t%w", ош)
 	}
 	игроковОнлайн, ош := static_param.НовСтатПарам("online")
 	if ош != nil {
-		return nil, fmt.Errorf("NewAngar(): при создании статистики игроков онлайн, ош=\n\t%w", ош)
+		return nil, fmt.Errorf("НовАнгар(): при создании статистики игроков онлайн, ош=\n\t%w", ош)
 	}
 	сереброВсего, ош := static_param.НовСтатПарам("silver_all")
 	if ош != nil {
-		return nil, fmt.Errorf("NewAngar(): при создании статистики серебра всего, ош=\n\t%w", ош)
+		return nil, fmt.Errorf("НовАнгар(): при создании статистики серебра всего, ош=\n\t%w", ош)
 	}
 	сереброСессия, ош := static_param.НовСтатПарам("silver_online")
 	if ош != nil {
-		return nil, fmt.Errorf("NewAngar(): при создании статистики серебра заработанного за сессию, ош=\n\t%w", ош)
+		return nil, fmt.Errorf("НовАнгар(): при создании статистики серебра заработанного за сессию, ош=\n\t%w", ош)
 	}
 	sf := &Angar{
 		Section:       section,
-		bot:           bot,
+		бот:           bot,
 		золото:        золото,
 		уровень:       уровень,
 		progress:      прогресс,
@@ -96,58 +96,58 @@ func NewAngar(bot types.ИБот) (*Angar, error) {
 		silverOnline: сереброСессия,
 	}
 	{ // Сеть
-		sf.net, err = angarnet.NewAngarNet(sf)
+		sf.сеть, err = angarnet.NewAngarNet(sf)
 		if err != nil {
-			return nil, fmt.Errorf("NewAngar(): in create <AngarNet>, err=\n\t%w", err)
+			return nil, fmt.Errorf("НовАнгар(): in create <AngarNet>, err=\n\t%w", err)
 		}
 	}
 	{ // Сеть атаки
 		sf.netKill, err = angar_attack.NewAngarAttack(sf)
 		if err != nil {
-			return nil, fmt.Errorf("NewAngar(): in create <AngarAttackNet>, err=\n\t%w", err)
+			return nil, fmt.Errorf("НовАнгар(): in create <AngarAttackNet>, err=\n\t%w", err)
 		}
 	}
 	{ // Статистика
-		sf.stat, err = netstat.NewNetStat(sf.bot)
+		sf.сетьСтат, err = netstat.NewNetStat(sf.бот)
 		if err != nil {
-			return nil, fmt.Errorf("NewAngar(): in create NetResource, err=\n\t%w", err)
+			return nil, fmt.Errorf("НовАнгар(): in create NetResource, err=\n\t%w", err)
 		}
 	}
 	{ // Convoy
-		sf.convoy, err = convoy.NewConvoy(sf.bot)
+		sf.конвой, err = convoy.NewConvoy(sf.бот)
 		if err != nil {
-			return nil, fmt.Errorf("NewAngar(): in create IConvoy, err=\n\t%w", err)
+			return nil, fmt.Errorf("НовАнгар(): in create IConvoy, err=\n\t%w", err)
 		}
 	}
 	{ // Сражение
-		sf.battle, err = battle.NewBattle(sf.bot)
+		sf.сражение, err = battle.NewBattle(sf.бот)
 		if err != nil {
-			return nil, fmt.Errorf("NewAngar(): in create IBattle, err=\n\t%w", err)
+			return nil, fmt.Errorf("НовАнгар(): in create IBattle, err=\n\t%w", err)
 		}
 	}
 	{ // Битва мастеров
-		sf.batMas, err = batmas.NewBatMas(sf.bot)
+		sf.битва, err = batmas.NewBatMas(sf.бот)
 		if err != nil {
-			return nil, fmt.Errorf("NewAngar(): in create *BatMas, err=\n\t%w", err)
+			return nil, fmt.Errorf("НовАнгар(): in create *BatMas, err=\n\t%w", err)
 		}
 		// go sf.batMas.Run()
 	}
 	{ // База
-		sf.base, err = base.NewBase(sf)
+		sf.база, err = base.NewBase(sf)
 		if err != nil {
-			return nil, fmt.Errorf("NewAngar(): in make IBase, err=\n\t%w", err)
+			return nil, fmt.Errorf("НовАнгар(): in make IBase, err=\n\t%w", err)
 		}
 	}
 	{ // Миссии
-		sf.missions, err = missions.NewMissions(sf.bot)
+		sf.миссии, err = missions.NewMissions(sf.бот)
 		if err != nil {
-			return nil, fmt.Errorf("NewAngar(): in make *Missions, err=\n\t%w", err)
+			return nil, fmt.Errorf("НовАнгар(): in make *Missions, err=\n\t%w", err)
 		}
 	}
 	{ // Топливо
-		sf.fuel, err = fuel.NewFuel(sf)
+		sf.топливо, err = fuel.NewFuel(sf)
 		if err != nil {
-			return nil, fmt.Errorf("NewAngar(): in make *Missions, err=\n\t%w", err)
+			return nil, fmt.Errorf("НовАнгар(): in make *Missions, err=\n\t%w", err)
 		}
 	}
 	return sf, nil
@@ -159,22 +159,22 @@ func (sf *Angar) Пуск() error {
 		if err := sf.netKill.Run(); err != nil {
 			return fmt.Errorf("Angar.Run(): при пуске сетевой секции опыт за топливо, err=\n\t%w", err)
 		}
-		if err := sf.convoy.Run(); err != nil {
+		if err := sf.конвой.Run(); err != nil {
 			return fmt.Errorf("Angar.Run(): при пуске конвоя, err=\n\t%w", err)
 		}
-		if err := sf.battle.Run(); err != nil {
+		if err := sf.сражение.Run(); err != nil {
 			return fmt.Errorf("Angar.Run(): при пуске сражения, err=\n\t%w", err)
 		}
-		if err := sf.batMas.Run(); err != nil {
+		if err := sf.битва.Run(); err != nil {
 			return fmt.Errorf("Angar.Run(): при пуске схватки, err=\n\t%w", err)
 		}
-		if err := sf.base.Run(); err != nil {
+		if err := sf.база.Run(); err != nil {
 			return fmt.Errorf("Angar.Run(): при пуске базы, err=\n\t%w", err)
 		}
-		if err := sf.missions.Run(); err != nil {
+		if err := sf.миссии.Run(); err != nil {
 			return fmt.Errorf("Angar.Run(): при пуске наград, err=\n\t%w", err)
 		}
-		go sf.fuel.Run()
+		go sf.топливо.Run()
 	}
 
 	go func() {
@@ -182,12 +182,12 @@ func (sf *Angar) Пуск() error {
 		count := 0
 		for {
 			select {
-			case <-sf.bot.Кнт().Done(): // Отмена контекста
+			case <-sf.бот.Кнт().Done(): // Отмена контекста
 				sf.ВремяОпрос().Стоп()
 				return
 			case <-sf.ВремяОпрос().КаналСиг(): // Метка времени
 				sf.updateResurs()
-				sf.stat.Update()
+				sf.сетьСтат.Update()
 				switch count {
 				case 0:
 					sf.checkConvoy()
@@ -208,7 +208,7 @@ func (sf *Angar) Пуск() error {
 
 // Обновляет ресурсы ангара
 func (sf *Angar) updateResurs() {
-	if err := sf.net.UpdateLst(); err != nil {
+	if err := sf.сеть.UpdateLst(); err != nil {
 		// log._rintf("ERRO Angar.updateResurs(): при обработке ангара в сети, err=\n\t%v\n", err)
 		return
 	}
@@ -218,17 +218,17 @@ func (sf *Angar) updateResurs() {
 
 // IMissions -- возвращает ссылку на объект миссий
 func (sf *Angar) Миссии() types.ИМиссии {
-	return sf.missions
+	return sf.миссии
 }
 
 // Сражение -- возвращает объект сражения
 func (sf *Angar) Сражение() types.ИСражениеСцена {
-	return sf.battle
+	return sf.сражение
 }
 
 // Конвой -- возвращает объект конвоя
 func (sf *Angar) Конвой() types.Конвой {
-	return sf.convoy
+	return sf.конвой
 }
 
 // Золото -- возвращает объект золота
@@ -238,7 +238,7 @@ func (sf *Angar) Золото() types.ИСтатПарам {
 
 // Топливо -- возвращает объект топлива
 func (sf *Angar) Топливо() types.ИСтатПарам {
-	return sf.fuel.Fuel()
+	return sf.топливо.Fuel()
 }
 
 // Уровень -- возвращает объект уровня игрока
@@ -286,9 +286,9 @@ func (sf *Angar) СереброОбновить(silverFact int) {
 
 // База -- возвращает базу
 func (sf *Angar) База() types.ИБаза {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	return sf.base
+	sf.блок.Lock()
+	defer sf.блок.Unlock()
+	return sf.база
 }
 
 // Проверяет на исполнение конвоя
@@ -310,7 +310,7 @@ func (sf *Angar) checkConvoy() {
 	if !strings.Contains(strOut, `<a class="simple-but border gray mb1" href="convoy"><span><span>Конвой</span></span></a>`) {
 		return
 	}
-	sf.convoy.UpdateLst()
+	sf.конвой.UpdateLst()
 }
 
 // Ищет в теле текста ангара серебро
@@ -338,7 +338,7 @@ func (sf *Angar) findSilver() {
 // Ищет в теле текста ангара золото
 func (sf *Angar) findGold() {
 	var (
-		lstAngar = sf.bot.Ангар().СписПолучить()
+		lstAngar = sf.бот.Ангар().СписПолучить()
 		strOut   string
 		isFind   bool
 	)
@@ -361,5 +361,5 @@ func (sf *Angar) findGold() {
 		// log._rintf("ERRO AngarNet.findGold(): gold(%v) not number, err=\n\t%v\n", strGold, err)
 		return
 	}
-	sf.bot.Ангар().Золото().Уст(iGold)
+	sf.бот.Ангар().Золото().Уст(iGold)
 }

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

@@ -65,7 +65,7 @@ func НовАрсенал(base types.ИБаза) (*Арсенал, error) {
 			return nil, fmt.Errorf("NewArsenal(): in create NetArsenal, err=\n\t%w", err)
 		}
 	}
-_=types.ИАрсенал(сам)
+	_ = types.ИАрсенал(сам)
 	return сам, nil
 }
 

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

@@ -122,15 +122,16 @@ func (sf *Polygon) checkForce() {
 		return
 	}
 	strOut = lstPolygon[ind]
+	форсажИмя := ""
 	switch { // Вычисляем контрольную строку
 	case strings.Contains(strOut, `>улучшение точности<`):
-		sf.tankStat.ПарамФорсаж().SetName("fyne")
+		форсажИмя = "fyne"
 	case strings.Contains(strOut, `>увеличение прочности<`):
-		sf.tankStat.ПарамФорсаж().SetName("hard")
+		форсажИмя = "hard"
 	case strings.Contains(strOut, `>усиление брони<`):
-		sf.tankStat.ПарамФорсаж().SetName("armor")
+		форсажИмя = "armor"
 	case strings.Contains(strOut, `>усиление атаки<`):
-		sf.tankStat.ПарамФорсаж().SetName("attack")
+		форсажИмя = "attack"
 	}
 	// Вычислим на сколько
 	strOut = lstPolygon[ind+1]
@@ -143,7 +144,7 @@ func (sf *Polygon) checkForce() {
 		// log._rintf("NetPolygon.checkTime(): force(%v) not number, err=\n\t%v\n", strOut, err)
 		return
 	}
-	sf.tankStat.ПарамФорсаж().Уст(iForce)
+	sf.tankStat.ФорсажОбнов(форсажИмя, iForce)
 }
 
 // Выбирает самый слабый параметр и усиливает его
@@ -230,8 +231,7 @@ func (sf *Polygon) addForce() {
 				// log._rintf("ERRO NetPolygon.addForce(): strForceAttack(%v) not int, err=\n\t%v\n", strForce, err)
 				return
 			}
-			sf.tankStat.ПарамФорсаж().Уст(iForce)
-			sf.tankStat.ПарамФорсаж().SetName("attack")
+			sf.tankStat.ФорсажОбнов("attack", iForce)
 			sf.РежимТекущ().Уст("атака")
 		}
 	case "armor": // Усиливаем броню
@@ -269,8 +269,7 @@ func (sf *Polygon) addForce() {
 				// log._rintf("ERRO NetPolygon.addForce(): strForceArmor(%v) not int, err=\n\t%v\n", strForce, err)
 				return
 			}
-			sf.tankStat.ПарамФорсаж().Уст(iForce)
-			sf.tankStat.ПарамФорсаж().SetName("armor")
+			sf.tankStat.ФорсажОбнов("armor", iForce)
 			sf.РежимТекущ().Уст("броня")
 		}
 	case "fyne": // Усиливаем точность
@@ -308,8 +307,7 @@ func (sf *Polygon) addForce() {
 				// log._rintf("ERRO NetPolygon.addForce(): strForceFyne(%v) not int, err=\n\t%v\n", strForce, err)
 				return
 			}
-			sf.tankStat.ПарамФорсаж().Уст(iForce)
-			sf.tankStat.ПарамФорсаж().SetName("fyne")
+			sf.tankStat.ФорсажОбнов("fyne", iForce)
 			sf.РежимТекущ().Уст("точность")
 		}
 	case "hard": // Усиливаем мощность
@@ -344,8 +342,7 @@ func (sf *Polygon) addForce() {
 				// log._rintf("ERRO NetPolygon.addForce(): strForceHard(%v) not int, err=\n\t%v\n", strForce, err)
 				return
 			}
-			sf.tankStat.ПарамФорсаж().Уст(iForce)
-			sf.tankStat.ПарамФорсаж().SetName("hard")
+			sf.tankStat.ФорсажОбнов("hard", iForce)
 			sf.РежимТекущ().Уст("прочность")
 		}
 	default: // Неизвестно что

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

@@ -16,10 +16,10 @@ import (
 // BattleWorker -- исполнение битвы
 type BattleWorker struct {
 	*section.Section
-	bot types.ИБот
+	бот types.ИБот
 	net *sectionnet.SectionNet
 
-	alarm types.ИСтатПарам
+	еслиНачало types.ИСтатПарам
 
 	// Непосредственное сражение
 	baton *battleon.BattleOn
@@ -33,11 +33,15 @@ func NewBattleWorker(bot types.ИБот) (*BattleWorker, error) {
 	if err != nil {
 		return nil, fmt.Errorf("NewBattleWorker(): in create *Section, err=\n\t%w", err)
 	}
+	еслиНачало, ош := static_param.НовСтатПарам("alarm")
+	if ош != nil {
+		return nil, fmt.Errorf("NewBattleWorker(): при создании стат еслиНачало, err=\n\t%w", ош)
+	}
 	sf := &BattleWorker{
-		Section: section,
-		bot:     bot,
-		alarm:   static_param.НовСтатПарам("alarm"),
-		sound:   battlesound.NewBattleSound(),
+		Section:    section,
+		бот:        bot,
+		еслиНачало: еслиНачало,
+		sound:      battlesound.NewBattleSound(),
 	}
 	sf.net, err = sectionnet.NewSectionNet(sf, "http://wartank.ru/pve")
 	if err != nil {
@@ -49,14 +53,14 @@ func NewBattleWorker(bot types.ИБот) (*BattleWorker, error) {
 // Work -- выполняет битву
 func (sf *BattleWorker) Work() {
 	var err error
-	sf.baton, err = battleon.NewBattleOn(sf.bot) // IBattleOn (онлайн)
+	sf.baton, err = battleon.NewBattleOn(sf.бот) // IBattleOn (онлайн)
 	if err != nil {
 		return
 	}
-	sf.alarm.Уст(1)
+	sf.еслиНачало.Уст(1)
 	sf.sound.Play()
 	time.Sleep(time.Second * 10) // Задержка для звука на странице
-	sf.alarm.Уст(0)
+	sf.еслиНачало.Уст(0)
 	// Ожидание завершения
 	<-sf.baton.Кнт().Done()
 	sf.baton = nil
@@ -66,5 +70,5 @@ func (sf *BattleWorker) Work() {
 
 // Alarm -- возвращает признак начала сражения (для браузера)
 func (sf *BattleWorker) Alarm() types.ИСтатПарам {
-	return sf.alarm
+	return sf.еслиНачало
 }

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

@@ -23,8 +23,8 @@ import (
 type Convoy struct {
 	*section.Section
 	net      *convoynet.ConvoyNet
-	bot      types.ИБот
-	glory    types.ИСтатПарам // Количество славы
+	бот      types.ИБот
+	слава    types.ИСтатПарам // Количество славы
 	chAttack chan int         // Канал проведения атаки
 }
 
@@ -34,10 +34,14 @@ func NewConvoy(bot types.ИБот) (*Convoy, error) {
 	if err != nil {
 		return nil, fmt.Errorf("NewConvoy(): in create ISection, err=\n\t%w", err)
 	}
+	слава, ош := static_param.НовСтатПарам("glory")
+	if ош != nil {
+		return nil, fmt.Errorf("NewConvoy(): при создании статы славы, err=\n\t%w", ош)
+	}
 	sf := &Convoy{
 		Section:  section,
-		bot:      bot,
-		glory:    static_param.НовСтатПарам("glory"),
+		бот:      bot,
+		слава:    слава,
 		chAttack: make(chan int, 5),
 	}
 	sf.net, err = convoynet.NewConvoyNet(sf)
@@ -63,7 +67,7 @@ func (sf *Convoy) UpdateLst() {
 
 // Слава --возвращает счётчик славы конвоя
 func (sf *Convoy) Слава() types.ИСтатПарам {
-	return sf.glory
+	return sf.слава
 }
 
 // Если время конвоя замерло -- посылает контрольный сигнал на атаку
@@ -73,7 +77,7 @@ func (sf *Convoy) reservTick() {
 	}()
 	for {
 		select {
-		case <-sf.bot.Кнт().Done():
+		case <-sf.бот.Кнт().Done():
 			return
 		default:
 			ct0 := sf.ВремяОпрос().Получ()
@@ -92,7 +96,7 @@ func (sf *Convoy) run() {
 	sf.chAttack <- 1
 	for {
 		select {
-		case <-sf.bot.Кнт().Done():
+		case <-sf.бот.Кнт().Done():
 			sf.ВремяОпрос().Стоп()
 			return
 		case <-sf.ВремяОпрос().КаналСиг(): // Время истекло
@@ -133,7 +137,7 @@ func (sf *Convoy) updateGlory() {
 		// log._rintf("ERRO ConvoyNet.updateGlory(): слава(%v) не число, err=\n\t%v\n", strGlory, err)
 		return
 	}
-	sf.glory.Уст(iGlory)
+	sf.слава.Уст(iGlory)
 }
 
 // Обновляет оставшееся время конвоя

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

@@ -43,10 +43,13 @@ func NewDivWar(bot types.ИБот) (*DivWar, error) {
 	if bot == nil {
 		return nil, fmt.Errorf("NewDivWar(): IBot == nil")
 	}
-
+	еслиНач, ош := static_param.НовСтатПарам("alarm")
+	if ош != nil {
+		return nil, fmt.Errorf("NewDivWar(): при создании стат еслиНач, ош=\n\t%w", ош)
+	}
 	sf := &DivWar{
 		bot:      bot,
-		alarm:    static_param.НовСтатПарам("alarm"),
+		alarm:    еслиНач,
 		chDivWar: make(chan int, 1),
 		sound:    divwarsound.NewDivWarSound(),
 		conn:     bot.Сеть().Коннект(),

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

@@ -13,8 +13,8 @@ import (
 
 // Fuel -- топливо в баке
 type Fuel struct {
-	angar types.ИАнгар
-	fuel  types.ИСтатПарам
+	ангар   types.ИАнгар
+	топливо types.ИСтатПарам
 }
 
 // NewFuel -- возвращает новый топливный бак
@@ -22,9 +22,13 @@ func NewFuel(angar types.ИАнгар) (*Fuel, error) {
 	if angar == nil {
 		return nil, fmt.Errorf("NewFuel(): IAngar == nil")
 	}
+	топливо, ош := static_param.НовСтатПарам("fuel")
+	if ош != nil {
+		return nil, fmt.Errorf("NewFuel(): при создании стат топливо, ош=\n\t%w", ош)
+	}
 	sf := &Fuel{
-		angar: angar,
-		fuel:  static_param.НовСтатПарам("fuel"),
+		ангар:   angar,
+		топливо: топливо,
 	}
 	return sf, nil
 }
@@ -34,15 +38,15 @@ func (sf *Fuel) Run() {
 	count := 0 // Каждые 1500 сек (100 топлива проверять принудительно)
 	for {
 		time.Sleep(time.Second * 15)
-		if sf.fuel.Получ() == 0 || count >= 100 {
+		if sf.топливо.Получ() == 0 || count >= 100 {
 			sf.findFuel()
 			count = 0
 			continue
 		}
 		count++
-		fuel := sf.fuel.Получ()
+		fuel := sf.топливо.Получ()
 		fuel++
-		sf.fuel.Уст(fuel)
+		sf.топливо.Уст(fuel)
 		// log.Printf("Fuel.Run: val=%v\n", fuel)
 	}
 }
@@ -50,10 +54,10 @@ func (sf *Fuel) Run() {
 // Ищет в теле текста ангара топливо
 func (sf *Fuel) findFuel() {
 	// _mt.Println("\tAngarNet.findFuel()")
-	if sf.fuel.Получ() > 314 {
+	if sf.топливо.Получ() > 314 {
 		return
 	}
-	lstAngar := sf.angar.СписПолучить()
+	lstAngar := sf.ангар.СписПолучить()
 	var strOut string
 	for _, strFuel := range lstAngar {
 		if strings.Contains(strFuel, `<img title="Топливо" `) {
@@ -73,7 +77,7 @@ func (sf *Fuel) findFuel() {
 		// log._rintf("ERRO Fuel.findFuel(): fuel(%v) not number, err=\n\t%v\n", strFuel, err)
 		return
 	}
-	sf.fuel.Уст(iFuel)
+	sf.топливо.Уст(iFuel)
 	if iFuel <= 314 { // Минимальное значение "топливного склада-1" -- 315
 		return
 	}
@@ -82,5 +86,5 @@ func (sf *Fuel) findFuel() {
 
 // Fuel -- возвращает объект сстатическог опараметра топлива
 func (sf *Fuel) Fuel() types.ИСтатПарам {
-	return sf.fuel
+	return sf.топливо
 }

server/serv_bots/warbot/tank/tank.go

@@ -1,6 +1,7 @@
 package tank
 
 import (
+	"fmt"
 	"wartank/pkg/types"
 	"wartank/server/serv_bots/warbot/tank/tankstat"
 )
@@ -10,20 +11,24 @@ import (
 	Глобальный объект.
 */
 
-// Tank -- описатель танка
-type Tank struct {
-	statTank types.ИТанкСтат // Глобальная статистика танка и сервера
+// Танк -- описатель танка
+type Танк struct {
+	параметры types.ИТанкСтат // Глобальная статистика танка и сервера
 }
 
 // NewTank -- возвращает новый *Tank
-func NewTank() *Tank {
-	sf := &Tank{
-		statTank: tankstat.NewTankStat(),
+func NewTank() (*Танк, error) {
+	стата, ош := tankstat.NewTankStat()
+	if ош != nil {
+		return nil, fmt.Errorf("NewTank(): при создании статы, ош=\n\t%w", ош)
 	}
-	return sf
+	sf := &Танк{
+		параметры: стата,
+	}
+	return sf, nil
 }
 
 // ТанкСтат -- возвращает объект статистики танка
-func (sf *Tank) ТанкСтат() types.ИТанкСтат {
-	return sf.statTank
+func (sf *Танк) ТанкСтат() types.ИТанкСтат {
+	return sf.параметры
 }

server/serv_bots/warbot/tank/tankstat/static_param/static_param.go

@@ -15,7 +15,7 @@ import (
 // СтатПарам -- потокобезопасный параметр танка
 type СтатПарам struct {
 	имя  string // Имя параметра
-	знач   int    // Значение параметра
+	знач int    // Значение параметра
 	блок sync.RWMutex
 }
 
@@ -27,8 +27,8 @@ func НовСтатПарам(имя string) (*СтатПарам, error) {
 	сам := &СтатПарам{
 		имя: имя,
 	}
-	_=types.ИСтатПарам(сам)
-	return сам
+	_ = types.ИСтатПарам(сам)
+	return сам, nil
 }
 
 // Уст -- устанавливает значение параметра

server/serv_bots/warbot/tank/tankstat/tankstat.go

@@ -1,6 +1,9 @@
 package tankstat
 
 import (
+	"fmt"
+	"log"
+
 	"wartank/pkg/types"
 	"wartank/server/serv_bots/warbot/tank/tankstat/static_param"
 )
@@ -12,45 +15,69 @@ import (
 
 // TankStat -- статические параметры танка
 type TankStat struct {
-	attack types.ИСтатПарам // Сила атаки танка
-	fyne   types.ИСтатПарам // Точность танка
-	armor  types.ИСтатПарам // Броня танка
-	hard   types.ИСтатПарам // Броня танка
-	power  types.ИСтатПарам // Танковая мощь (может не совпадать по сумме, если есть усиление)
-	force  types.ИСтатПарам
+	атака     types.ИСтатПарам // Сила атаки танка
+	точность  types.ИСтатПарам // Точность танка
+	прочность types.ИСтатПарам // Броня танка
+	броня     types.ИСтатПарам // Броня танка
+	power     types.ИСтатПарам // Танковая мощь (может не совпадать по сумме, если есть усиление)
+	усиление  types.ИСтатПарам
 }
 
 // NewTankStat -- возвращает новый *TankStat
-func NewTankStat() *TankStat {
+func NewTankStat() (*TankStat, error) {
+	атака, ош := static_param.НовСтатПарам("attack")
+	if ош != nil {
+		return nil, fmt.Errorf("НовТанкСтат(): при создании статы атаки, ош=\n\t%w", ош)
+	}
+	точность, ош := static_param.НовСтатПарам("fyne")
+	if ош != nil {
+		return nil, fmt.Errorf("НовТанкСтат(): при создании статы точности, ош=\n\t%w", ош)
+	}
+	прочность, ош := static_param.НовСтатПарам("armor")
+	if ош != nil {
+		return nil, fmt.Errorf("НовТанкСтат(): при создании статы прочности, ош=\n\t%w", ош)
+	}
+	броня, ош := static_param.НовСтатПарам("hard")
+	if ош != nil {
+		return nil, fmt.Errorf("НовТанкСтат(): при создании статы брони, ош=\n\t%w", ош)
+	}
+	мощь, ош := static_param.НовСтатПарам("power")
+	if ош != nil {
+		return nil, fmt.Errorf("НовТанкСтат(): при создании статы мощи, ош=\n\t%w", ош)
+	}
+	усиление, ош := static_param.НовСтатПарам("force")
+	if ош != nil {
+		return nil, fmt.Errorf("НовТанкСтат(): при создании статы усиления, ош=\n\t%w", ош)
+	}
 	sf := &TankStat{
-		attack: static_param.НовСтатПарам("attack"),
-		fyne:   static_param.НовСтатПарам("fyne"),
-		armor:  static_param.НовСтатПарам("armor"),
-		hard:   static_param.НовСтатПарам("hard"),
-		power:  static_param.НовСтатПарам("power"),
-		force:  static_param.НовСтатПарам("force"),
+		атака:     атака,
+		точность:  точность,
+		прочность: прочность,
+		броня:     броня,
+		power:     мощь,
+		усиление:  усиление,
 	}
-	return sf
+	return sf, nil
 }
 
 // Атака -- возвращает объект силы атаки
 func (sf *TankStat) Атака() types.ИСтатПарам {
-	return sf.attack
+	return sf.атака
 }
 
 // Прочность -- возвращает объект прочности танка
 func (sf *TankStat) Прочность() types.ИСтатПарам {
-	return sf.hard
+	return sf.броня
 }
 
 // Точность -- возвращает объект точности танка
 func (sf *TankStat) Точность() types.ИСтатПарам {
-	return sf.fyne
+	return sf.точность
 }
 
 // Броня -- возвращает объект брони танка
 func (sf *TankStat) Броня() types.ИСтатПарам {
-	return sf.armor
+	return sf.прочность
 }
 
 // Мощь -- возвращает объект мощи танка
@@ -58,7 +85,18 @@ func (sf *TankStat) Мощь() types.ИСтатПарам {
 	return sf.power
 }
 
-// ПарамФорсаж -- возвращает объект форсированного параметра
-func (sf *TankStat) ПарамФорсаж() types.ИСтатПарам {
-	return sf.force
+// Форсаж -- возвращает объект форсированного параметра
+func (sf *TankStat) Форсаж() types.ИСтатПарам {
+	return sf.усиление
+}
+
+// Форсаж -- возвращает объект форсированного параметра
+func (сам *TankStat) ФорсажОбнов(парам string, знач int) {
+	var ош error
+	сам.усиление, ош = static_param.НовСтатПарам("force")
+	if ош != nil {
+		log.Printf("НовТанкСтат(): при создании статы усиления, ош=\n\t%v\n", ош)
+		panic("TanStat.ФорсажОбнов()")
+	}
+	сам.усиление.Уст(знач)
 }

server/serv_bots/warbot/warbot.go

@@ -15,83 +15,83 @@ import (
 	"wartank/server/serv_bots/warbot/warbot_net"
 )
 
-// WarBot -- бот для игры в вартанк
-type WarBot struct {
-	server    types.ИСервер
-	store     types.IStore
-	tank      *tank.Tank
-	errFinal  error // Финальная ошибка работы, если была
-	angar     types.ИАнгар
-	botNet    types.ИБотСеть
-	isRun     *safebool.SafeBool
-	isAutoRun *safebool.SafeBool
-	config    *warbot_config.WarBotConfig // Конфиг бота для хранения в базе
-	ctx       context.Context             // Контекст бота
-	fnCancel  func()                      // Функция отменя контекста бота
-}
-
-// LoadWarBot -- загружает бота из базы
-func LoadWarBot(server types.ИСервер, login string) (*WarBot, error) {
+// ВарБот -- бот для игры в вартанк
+type ВарБот struct {
+	сервер         types.ИСервер
+	store          types.IStore
+	танк           *tank.Танк
+	errFinal       error // Финальная ошибка работы, если была
+	ангар          types.ИАнгар
+	сеть           types.ИБотСеть
+	еслиРаботает   *safebool.SafeBool
+	еслиАвтозапуск *safebool.SafeBool
+	конфиг         *warbot_config.ВарБотКонфиг // Конфиг бота для хранения в базе
+	кнт            context.Context             // Контекст бота
+	фтОтмена       func()                      // Функция отменя контекста бота
+}
+
+// ЗагрузитьВарБот -- загружает бота из базы
+func ЗагрузитьВарБот(сервер types.ИСервер, логин string) (*ВарБот, error) {
 	{ // Предусловия
-		if server == nil {
-			return nil, fmt.Errorf("LoadWarBot(): IApp is nil")
+		if сервер == nil {
+			return nil, fmt.Errorf("ЗагрузитьВарБот(): IApp is nil")
 		}
-		if login == "" {
-			return nil, fmt.Errorf("LoadWarBot(): name is empty")
+		if логин == "" {
+			return nil, fmt.Errorf("ЗагрузитьВарБот(): name is empty")
 		}
 	}
-	log.Printf("LoadWarBot(): name=%q\n", login)
-	store := server.Store()
-	strData, err := store.Get("/bots/" + login)
+	log.Printf("ЗагрузитьВарБот(): name=%q\n", логин)
+	store := сервер.Store()
+	strData, err := store.Get("/bots/" + логин)
 	if err != nil {
 		if !strings.Contains(err.Error(), "not found") {
-			return nil, fmt.Errorf("LoadWarBot(): in load bot %q from store, err=\n\t%w", login, err)
+			return nil, fmt.Errorf("ЗагрузитьВарБот(): in load bot %q from store, err=\n\t%w", логин, err)
 		}
-		return nil, fmt.Errorf("LoadWarBot(): bot %q not found in store", login)
+		return nil, fmt.Errorf("ЗагрузитьВарБот(): bot %q not found in store", логин)
 	}
-	config := &warbot_config.WarBotConfig{}
-	if err = config.Unmarshall(strData); err != nil {
-		return nil, fmt.Errorf("LoadWarBot(): in unmarshall WarBotConfig(%q) from store, err=\n\t%w", login, err)
+	конфиг := &warbot_config.ВарБотКонфиг{}
+	if err = конфиг.Unmarshall(strData); err != nil {
+		return nil, fmt.Errorf("ЗагрузитьВарБот(): in unmarshall WarBotConfig(%q) from store, err=\n\t%w", логин, err)
 	}
-	sf, err := makeCoreWarBot(server, config)
+	sf, err := создатьЯдроВарБот(сервер, конфиг)
 	if err != nil {
-		return nil, fmt.Errorf("NewWarBot(): in make core for bot %q, err=\n\t%w", login, err)
+		return nil, fmt.Errorf("ЗагрузитьВарБот(): in make core for bot %q, err=\n\t%w", логин, err)
 	}
 	return sf, nil
 
 }
 
-// NewWarBot -- возвращает новый WarBot
-func NewWarBot(server types.ИСервер, login, pass string) (*WarBot, error) {
+// НовВарБот -- возвращает новый WarBot
+func НовВарБот(сервер types.ИСервер, логин, пароль string) (*ВарБот, error) {
 	{ // Предусловия
-		if server == nil {
-			return nil, fmt.Errorf("NewWarBot(): IApp is nil")
+		if сервер == nil {
+			return nil, fmt.Errorf("НовВарБот(): IApp is nil")
 		}
-		if login == "" {
-			return nil, fmt.Errorf("NewWarBot(): login is empty")
+		if логин == "" {
+			return nil, fmt.Errorf("НовВарБот(): login is empty")
 		}
-		if pass == "" {
-			return nil, fmt.Errorf("NewWarBot(): pass is empty")
+		if пароль == "" {
+			return nil, fmt.Errorf("НовВарБот(): pass is empty")
 		}
 	}
-	log.Printf("NewWarBot(): name=%q\n", login)
-	config := &warbot_config.WarBotConfig{
-		IsAutoRun_: false,
-		Login_:     login,
-		Password_:  pass,
+	log.Printf("НовВарБот(): name=%q\n", логин)
+	config := &warbot_config.ВарБотКонфиг{
+		ЕслиАвтозапуск_: false,
+		Логин_:          логин,
+		Пароль_:         пароль,
 	}
-	sf, err := makeCoreWarBot(server, config)
+	sf, err := создатьЯдроВарБот(сервер, config)
 	if err != nil {
-		return nil, fmt.Errorf("NewWarBot(): in make core bot %q, err=\n\t%w", login, err)
+		return nil, fmt.Errorf("НовВарБот(): in make core bot %q, err=\n\t%w", логин, err)
 	}
 	if err := sf.save(); err != nil {
-		return nil, fmt.Errorf("NewWarBot(): in self save to store, err=\n\t%w", err)
+		return nil, fmt.Errorf("НовВарБот(): in self save to store, err=\n\t%w", err)
 	}
 	return sf, nil
 }
 
 // Создаёт ядро бота
-func makeCoreWarBot(server types.ИСервер, config *warbot_config.WarBotConfig) (*WarBot, error) {
+func создатьЯдроВарБот(server types.ИСервер, config *warbot_config.ВарБотКонфиг) (*ВарБот, error) {
 	{ // Предусловия
 		if server == nil {
 			return nil, fmt.Errorf("NewWarBot(): IServer==nil")
@@ -100,112 +100,116 @@ func makeCoreWarBot(server types.ИСервер, config *warbot_config.WarBotCon
 			return nil, fmt.Errorf("NewWarBot(): WarBotConfig==nil")
 		}
 	}
+	танк, ош := tank.NewTank()
+	if ош != nil {
+		return nil, fmt.Errorf("NewWarBot(): при создании параметров танка, ош=\n\t%w", ош)
+	}
 	ctx, fnCancel := context.WithCancel(server.CtxApp())
-	sf := &WarBot{
-		server:    server,
-		store:     server.Store(),
-		tank:      tank.NewTank(),
-		isRun:     safebool.NewSafeBool(),
-		isAutoRun: safebool.NewSafeBool(),
-		config:    config,
-		ctx:       ctx,
-		fnCancel:  fnCancel,
+	sf := &ВарБот{
+		сервер:         server,
+		store:          server.Store(),
+		танк:           танк,
+		еслиРаботает:   safebool.NewSafeBool(),
+		еслиАвтозапуск: safebool.NewSafeBool(),
+		конфиг:         config,
+		кнт:            ctx,
+		фтОтмена:       fnCancel,
 	}
 	var err error
 	{ // WarBotNet
-		sf.botNet, err = warbot_net.NewWarBotNet(sf)
+		sf.сеть, err = warbot_net.NewWarBotNet(sf)
 		if err != nil {
 			return nil, fmt.Errorf("NewWarBot(): in make IBotNet, err=\n\t%w", err)
 		}
 	}
-	sf.angar, err = angar.NewAngar(sf)
+	sf.ангар, err = angar.НовАнгар(sf)
 	if err != nil {
 		return nil, fmt.Errorf("NewWarBot(): bot(%q) in make IAngar, err=\n\t%w", sf.Имя(), err)
 	}
-	if sf.config.IsAutoRun_ {
-		sf.isAutoRun.Set()
+	if sf.конфиг.ЕслиАвтозапуск_ {
+		sf.еслиАвтозапуск.Set()
 		sf.Пуск()
 	}
 	return sf, nil
 }
 
 // Сервер -- возвращает ссылку на объект сервера
-func (sf *WarBot) Сервер() types.ИСервер {
-	return sf.server
+func (sf *ВарБот) Сервер() types.ИСервер {
+	return sf.сервер
 }
 
 // ЕслиПуск -- возвращает признак, что бот подключен
-func (sf *WarBot) ЕслиПуск() bool {
-	return sf.isRun.Get()
+func (sf *ВарБот) ЕслиПуск() bool {
+	return sf.еслиРаботает.Get()
 }
 
 // Имя -- возвращает имя бота
-func (sf *WarBot) Имя() string {
-	return sf.config.Login_
+func (sf *ВарБот) Имя() string {
+	return sf.конфиг.Логин_
 }
 
 // Пароль -- возвращает пароль бота
-func (sf *WarBot) Пароль() string {
-	return sf.config.Password_
+func (sf *ВарБот) Пароль() string {
+	return sf.конфиг.Пароль_
 }
 
 // Пуск -- запускает бот в работу
-func (sf *WarBot) Пуск() (err error) {
-	if sf.isRun.Get() {
+func (sf *ВарБот) Пуск() (err error) {
+	if sf.еслиРаботает.Get() {
 		return nil
 	}
-	if err := sf.angar.Пуск(); err != nil {
+	if err := sf.ангар.Пуск(); err != nil {
 		return fmt.Errorf("WarBot.Run(): bot(%q) in run angar, err=\n\t%w", sf.Имя(), err)
 	}
-	sf.isRun.Set()
+	sf.еслиРаботает.Set()
 	return nil
 }
 
 // Error -- возвращает финальную ошибку работы, если была
-func (sf *WarBot) Error() error {
+func (sf *ВарБот) Error() error {
 	return sf.errFinal
 }
 
 // Ангар -- возвращает ангар игры
-func (sf *WarBot) Ангар() types.ИАнгар {
-	return sf.angar
+func (sf *ВарБот) Ангар() types.ИАнгар {
+	return sf.ангар
 }
 
 // Танк -- возвращает объект танка
-func (sf *WarBot) Танк() types.ИТанк {
-	return sf.tank
+func (sf *ВарБот) Танк() types.ИТанк {
+	return sf.танк
 }
 
 // Сеть -- возвращает ссылку на свой сетевой клиент
-func (sf *WarBot) Сеть() types.ИБотСеть {
-	return sf.botNet
+func (sf *ВарБот) Сеть() types.ИБотСеть {
+	return sf.сеть
 }
 
 // АвтоИграЕсли -- возвращает признак автоматичского запуска бота
-func (sf *WarBot) АвтоИграЕсли() bool {
-	return sf.isAutoRun.Get()
+func (sf *ВарБот) АвтоИграЕсли() bool {
+	return sf.еслиАвтозапуск.Get()
 }
 
 // АвтоИграУст -- устанавливает признак автоматического запуска бота
-func (sf *WarBot) АвтоИграУст() {
+func (sf *ВарБот) АвтоИграУст() {
 	log.Printf("WarBot.SetAutoGame()")
-	sf.isAutoRun.Set()
-	sf.config.IsAutoRun_ = true
+	sf.еслиАвтозапуск.Set()
+	sf.конфиг.ЕслиАвтозапуск_ = true
 	sf.saveConfig()
 }
 
 // АвтоИграСброс -- сбрасывает признак автоматического запуска бота
-func (sf *WarBot) АвтоИграСброс() {
+func (sf *ВарБот) АвтоИграСброс() {
 	log.Printf("WarBot.ResetAutoGame()")
-	sf.isAutoRun.Set()
-	sf.config.IsAutoRun_ = false
+	sf.еслиАвтозапуск.Set()
+	sf.конфиг.ЕслиАвтозапуск_ = false
 	sf.saveConfig()
 }
 
 // Сохраняет конфиг бота
-func (sf *WarBot) saveConfig() {
+func (sf *ВарБот) saveConfig() {
 	log.Printf("WarBot.saveConfig()")
-	strConf := sf.config.Marshall()
+	strConf := sf.конфиг.Marshall()
 	err := sf.store.Put("/bots/"+sf.Имя(), strConf)
 	if err != nil {
 		log.Printf("WarBot.saveConfig(): err=\n\t%v\n", err)
@@ -213,18 +217,18 @@ func (sf *WarBot) saveConfig() {
 }
 
 // Кнт -- возвращает контекст бота
-func (sf *WarBot) Кнт() context.Context {
-	return sf.ctx
+func (sf *ВарБот) Кнт() context.Context {
+	return sf.кнт
 }
 
 // Закончить -- отменяет контекст бота
-func (sf *WarBot) Закончить() {
-	sf.fnCancel()
+func (sf *ВарБот) Закончить() {
+	sf.фтОтмена()
 }
 
 // Сохраняет себя в базу
-func (sf *WarBot) save() error {
-	err := sf.store.Put("/bots/"+sf.Имя(), sf.config.Marshall())
+func (sf *ВарБот) save() error {
+	err := sf.store.Put("/bots/"+sf.Имя(), sf.конфиг.Marshall())
 	if err != nil {
 		return fmt.Errorf("WarBot.save(): in self save to store bot(%q), err=\n\t%w", sf.Имя(), err)
 	}

server/serv_bots/warbot/warbot_config/warbot_config.go

@@ -6,21 +6,21 @@ import (
 	"fmt"
 )
 
-// WarBotConfig -- конфиг бота для хранения в базе
-type WarBotConfig struct {
-	IsAutoRun_ bool   `json:"is_auto_run,omitempty"` // Признак автостарта при загрузке
-	Login_     string `json:"login"`                 // Логин бота
-	Password_  string `json:"password"`              // Пароль бота
+// ВарБотКонфиг -- конфиг бота для хранения в базе
+type ВарБотКонфиг struct {
+	ЕслиАвтозапуск_ bool   `json:"is_auto_run,omitempty"` // Признак автостарта при загрузке
+	Логин_          string `json:"login"`                 // Логин бота
+	Пароль_         string `json:"password"`              // Пароль бота
 }
 
 // Marshall -- сериализует конфиг в JSON
-func (sf *WarBotConfig) Marshall() string {
+func (sf *ВарБотКонфиг) Marshall() string {
 	binData, _ := json.Marshal(sf)
 	return string(binData)
 }
 
 // Unmarshall -- десериализует себя из байтового потока
-func (sf *WarBotConfig) Unmarshall(strData string) error {
+func (sf *ВарБотКонфиг) Unmarshall(strData string) error {
 	err := json.Unmarshal([]byte(strData), sf)
 	if err != nil {
 		return fmt.Errorf("WarBotConfig.Unmarshall(): err=\n\t%w", err)