SVI Добавление кода

server/serv_bots/dict_warbot/dict_warbot.go

@@ -29,63 +29,63 @@ func NewDictWarBot(server types.ИСервер) (*DictWarBot, error) {
 		return nil, fmt.Errorf("NewDictWarBot(): IServer==nil")
 	}
 	log.Printf("NewDictWarBot()\n")
-	sf := &DictWarBot{
+	сам := &DictWarBot{
 		server: server,
 		store:  server.Store(),
 		dict:   map[string]types.ИБот{},
 	}
-	if err := sf.load(); err != nil {
+	if err := сам.load(); err != nil {
 		return nil, fmt.Errorf("NewDictBot(): in load list bots from store, err=%w", err)
 	}
-	return sf, nil
+	return сам, nil
 }
 
 // ListBot -- возвращает список существующих ботов
-func (sf *DictWarBot) ListBot() []types.ИБот {
-	sf.block.RLock()
-	defer sf.block.RUnlock()
+func (сам *DictWarBot) ListBot() []types.ИБот {
+	сам.block.RLock()
+	defer сам.block.RUnlock()
 	lst := make([]types.ИБот, 0)
-	for _, bot := range sf.dict {
+	for _, bot := range сам.dict {
 		lst = append(lst, bot)
 	}
 	return lst
 }
 
 // Get -- возвращает бота по имени
-func (sf *DictWarBot) Get(botName string) types.ИБот {
-	sf.block.RLock()
-	defer sf.block.RUnlock()
-	bot := sf.dict[botName]
+func (сам *DictWarBot) Get(botName string) types.ИБот {
+	сам.block.RLock()
+	defer сам.block.RUnlock()
+	bot := сам.dict[botName]
 	return bot
 }
 
 // Add -- добавляет нового бота в словарь
-func (sf *DictWarBot) Add(bot types.ИБот) {
-	sf.block.Lock()
-	defer sf.block.Unlock()
+func (сам *DictWarBot) Add(bot types.ИБот) {
+	сам.block.Lock()
+	defer сам.block.Unlock()
 	if bot == nil {
 		return
 	}
-	sf.dict[bot.Имя()] = bot
-	sf.save()
+	сам.dict[bot.Имя()] = bot
+	сам.save()
 }
 
 // Сохраняет словарь ботов в базе
-func (sf *DictWarBot) save() {
+func (сам *DictWarBot) save() {
 	strName := ""
-	for name := range sf.dict {
+	for name := range сам.dict {
 		strName += name + ";"
 	}
 	strName = strName[:len(strName)-1]
-	err := sf.store.Put(strBotList, strName)
+	err := сам.store.Put(strBotList, strName)
 	if err != nil {
-		sf.server.CancelApp()
+		сам.server.CancelApp()
 	}
 }
 
 // Загружает всех ботов с базы
-func (sf *DictWarBot) load() error {
-	strName, err := sf.store.Get(strBotList)
+func (сам *DictWarBot) load() error {
+	strName, err := сам.store.Get(strBotList)
 	if err != nil {
 		if !strings.Contains(err.Error(), "not found") {
 			return fmt.Errorf("DictWarBot.load(): in get list bot, err=\n\t%w", err)
@@ -99,18 +99,18 @@ func (sf *DictWarBot) load() error {
 		if name == "" {
 			continue
 		}
-		_, isOk := sf.dict[name]
+		_, isOk := сам.dict[name]
 		if isOk {
 			continue
 		}
-		bot, err := warbot.ЗагрузитьВарБот(sf.server, name)
+		bot, err := warbot.ЗагрузитьВарБот(сам.server, name)
 		if err != nil {
 			return fmt.Errorf("ServBots.load(): in create bot %q, err=\n\t%w", name, err)
 		}
 		if bot.АвтоИграЕсли() {
 			go bot.Пуск()
 		}
-		sf.dict[name] = bot
+		сам.dict[name] = bot
 	}
 	return nil
 }

server/serv_bots/serv_bots.go

@@ -34,14 +34,14 @@ func НовБотоФерма(серв types.ИСервер) (*БотоФерм
 }
 
 // Get -- возвращает боевого бота по имени
-func (sf *БотоФерма) Get(name string) types.ИБот {
-	bot := sf.dictBot.Get(name)
+func (сам *БотоФерма) Get(name string) types.ИБот {
+	bot := сам.dictBot.Get(name)
 	return bot
 }
 
 // BotStart -- запускает бота в работу по его имени
-func (sf *БотоФерма) BotStart(name string) error {
-	bot := sf.dictBot.Get(name)
+func (сам *БотоФерма) BotStart(name string) error {
+	bot := сам.dictBot.Get(name)
 	if bot == nil {
 		return fmt.Errorf("ServBots.BotStart(): bot(%v) not found", name)
 	}
@@ -53,25 +53,25 @@ func (sf *БотоФерма) BotStart(name string) error {
 }
 
 // ListBot -- возвращает список существующих ботов
-func (sf *БотоФерма) ListBot() []types.ИБот {
-	lst := sf.dictBot.ListBot()
+func (сам *БотоФерма) ListBot() []types.ИБот {
+	lst := сам.dictBot.ListBot()
 	return lst
 }
 
 // НовБот -- добавляет нового бота на ферму
-func (sf *БотоФерма) НовБот(логин, пароль string, еслиАвто bool) error {
+func (сам *БотоФерма) НовБот(логин, пароль string, еслиАвто bool) error {
 	{ // Существует ли такой бот
-		bot := sf.dictBot.Get(логин)
+		bot := сам.dictBot.Get(логин)
 		if bot != nil {
 			return nil
 		}
 	}
 	{ // Нет такого бота, надо его создать
-		bot, err := warbot.НовВарБот(sf.серв, логин, пароль, еслиАвто)
+		bot, err := warbot.НовВарБот(сам.серв, логин, пароль, еслиАвто)
 		if err != nil {
 			return fmt.Errorf("БотоФерма.НовБот(): in create bot %q, err=\n\t%w", логин, err)
 		}
-		sf.dictBot.Add(bot)
+		сам.dictBot.Add(bot)
 	}
 	return nil
 }

server/serv_bots/warbot/angar/angar.go

@@ -131,7 +131,7 @@ func НовАнгар(bot types.ИБот) (*Ангар, error) {
 		if err != nil {
 			return nil, fmt.Errorf("НовАнгар(): in create *BatMas, err=\n\t%w", err)
 		}
-		// go sf.batMas.Run()
+		// go сам.batMas.Run()
 	}
 	{ // База
 		сам.база, err = base.НовБаза(сам)
@@ -164,45 +164,45 @@ func (сам *Ангар) Обновить() {
 }
 
 // запускает обработку ангара
-func (sf *Ангар) Пуск() error {
+func (сам *Ангар) Пуск() error {
 	{ // Запуск компонентов
-		if err := sf.топливоБой.Пуск(); err != nil {
+		if err := сам.топливоБой.Пуск(); err != nil {
 			return fmt.Errorf("Ангар.Пуск(): при пуске сетевой секции опыт за топливо, err=\n\t%w", err)
 		}
-		if err := sf.конвой.Пуск(); err != nil {
+		if err := сам.конвой.Пуск(); err != nil {
 			return fmt.Errorf("Ангар.Пуск(): при пуске конвоя, err=\n\t%w", err)
 		}
-		if err := sf.сражение.Пуск(); err != nil {
+		if err := сам.сражение.Пуск(); err != nil {
 			return fmt.Errorf("Ангар.Пуск(): при пуске сражения, err=\n\t%w", err)
 		}
-		if err := sf.битва.Run(); err != nil {
+		if err := сам.битва.Run(); err != nil {
 			return fmt.Errorf("Ангар.Пуск(): при пуске схватки, err=\n\t%w", err)
 		}
-		if err := sf.база.Пуск(); err != nil {
+		if err := сам.база.Пуск(); err != nil {
 			return fmt.Errorf("Ангар.Пуск(): при пуске базы, err=\n\t%w", err)
 		}
-		if err := sf.миссии.Пуск(); err != nil {
+		if err := сам.миссии.Пуск(); err != nil {
 			return fmt.Errorf("Ангар.Пуск(): при пуске наград, err=\n\t%w", err)
 		}
-		go sf.топливо.Run()
+		go сам.топливо.Run()
 	}
 	фнЦикл := func() bool {
-		sf.Обновить()
-		// sf.конвойПроверить()
-		if err := sf.Секция.ОбратВремяУст("01:00"); err != nil {
-			sf.Отмена()
+		сам.Обновить()
+		// сам.конвойПроверить()
+		if err := сам.Секция.ОбратВремяУст("01:00"); err != nil {
+			сам.Отмена()
 			logrus.WithError(err).Errorln("Ангар.Run(): in update ICountTime")
 			return false
 		}
 		return true
 	}
 	go func() {
-		sf.Секция.ОбратВремяУст("01")
+		сам.Секция.ОбратВремяУст("01")
 		for {
 			select {
-			case <-sf.бот.Кнт().Done(): // Отмена контекста
+			case <-сам.бот.Кнт().Done(): // Отмена контекста
 				return
-			case <-sf.ВремяОстат().КаналСиг(): // Метка времени
+			case <-сам.ВремяОстат().КаналСиг(): // Метка времени
 				if !фнЦикл() {
 					return
 				}
@@ -228,107 +228,107 @@ func (сам *Ангар) РесурсыОбновить() {
 }
 
 // IMissions -- возвращает ссылку на объект миссий
-func (sf *Ангар) Миссии() types.ИМиссии {
-	return sf.миссии
+func (сам *Ангар) Миссии() types.ИМиссии {
+	return сам.миссии
 }
 
 // Сражение -- возвращает объект сражения
-func (sf *Ангар) Сражение() types.ИСражениеСцена {
-	return sf.сражение
+func (сам *Ангар) Сражение() types.ИСражениеСцена {
+	return сам.сражение
 }
 
 // Конвой -- возвращает объект конвоя
-func (sf *Ангар) Конвой() types.Конвой {
-	return sf.конвой
+func (сам *Ангар) Конвой() types.Конвой {
+	return сам.конвой
 }
 
 // Золото -- возвращает объект золота
-func (sf *Ангар) Золото() types.ИСтатПарам {
-	return sf.золото
+func (сам *Ангар) Золото() types.ИСтатПарам {
+	return сам.золото
 }
 
 // Топливо -- возвращает объект топлива
-func (sf *Ангар) Топливо() types.ИСтатПарам {
-	return sf.топливо.Fuel()
+func (сам *Ангар) Топливо() types.ИСтатПарам {
+	return сам.топливо.Fuel()
 }
 
 // Уровень -- возвращает объект уровня игрока
-func (sf *Ангар) Уровень() types.ИСтатПарам {
-	return sf.уровень
+func (сам *Ангар) Уровень() types.ИСтатПарам {
+	return сам.уровень
 }
 
 // Прогресс -- возвращает прогрес уровня игрока
-func (sf *Ангар) Прогресс() types.ИСтатПарам {
-	return sf.progress
+func (сам *Ангар) Прогресс() types.ИСтатПарам {
+	return сам.progress
 }
 
 // ИгрокиОнлайн -- возвращает количество игроков онлайн
-func (sf *Ангар) ИгрокиОнлайн() types.ИСтатПарам {
-	return sf.игроковОнлайн
+func (сам *Ангар) ИгрокиОнлайн() types.ИСтатПарам {
+	return сам.игроковОнлайн
 }
 
 // СереброВсего -- возвращает объект всего серебра в ангаре
-func (sf *Ангар) СереброВсего() types.ИСтатПарам {
-	return sf.сереброВсего
+func (сам *Ангар) СереброВсего() types.ИСтатПарам {
+	return сам.сереброВсего
 }
 
 // СереброЗаработаноСессия -- возвращает объект серебра за сессию в ангаре
-func (sf *Ангар) СереброЗаработаноСессия() types.ИСтатПарам {
-	return sf.silverOnline
+func (сам *Ангар) СереброЗаработаноСессия() types.ИСтатПарам {
+	return сам.silverOnline
 }
 
 // СереброОбновить -- на основе фактического серебра -- обновляет вырабатанное серебро
-func (sf *Ангар) СереброОбновить(silverFact int) {
-	if sf.сереброВсего.Получ() == 0 { // Если запуск
-		sf.сереброВсего.Уст(silverFact)
+func (сам *Ангар) СереброОбновить(silverFact int) {
+	if сам.сереброВсего.Получ() == 0 { // Если запуск
+		сам.сереброВсего.Уст(silverFact)
 		return
 	}
-	if sf.сереброВсего.Получ() > silverFact { // Если потрачего серебро
-		sf.сереброВсего.Уст(silverFact)
+	if сам.сереброВсего.Получ() > silverFact { // Если потрачего серебро
+		сам.сереброВсего.Уст(silverFact)
 		return
 	}
-	if sf.сереброВсего.Получ() < silverFact { // Если заработано
-		so := sf.silverOnline.Получ()
-		sd := silverFact - sf.сереброВсего.Получ()
-		sf.silverOnline.Уст(so + sd)
+	if сам.сереброВсего.Получ() < silverFact { // Если заработано
+		so := сам.silverOnline.Получ()
+		sd := silverFact - сам.сереброВсего.Получ()
+		сам.silverOnline.Уст(so + sd)
 	}
-	sf.сереброВсего.Уст(silverFact)
+	сам.сереброВсего.Уст(silverFact)
 }
 
 // База -- возвращает базу
-func (sf *Ангар) База() types.ИБаза {
-	sf.блок.Lock()
-	defer sf.блок.Unlock()
-	return sf.база
+func (сам *Ангар) База() types.ИБаза {
+	сам.блок.Lock()
+	defer сам.блок.Unlock()
+	return сам.база
 }
 
 /* Проверяет на исполнение конвоя
-func (sf *Ангар) конвойПроверить() {
+func (сам *Ангар) конвойПроверить() {
 	var (
 		strOut   string
-		isFind   bool
-		lstAngar = sf.СписПолучить()
+		iсамind   bool
+		lstAngar = сам.СписПолучить()
 	)
 	for _, strOut = range lstAngar {
 		if strings.Contains(strOut, `>Конвой</span>`) {
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind {
+	if !iсамind {
 		return
 	}
 	if !strings.Contains(strOut, `<a class="simple-but border gray mb1" href="convoy"><span><span>Конвой</span></span></a>`) {
 		return
 	}
-	sf.конвой.UpdateLst()
+	сам.конвой.UpdateLst()
 }
 */
 
 // Ищет в теле текста ангара серебро
-func (sf *Ангар) сереброНайти() {
+func (сам *Ангар) сереброНайти() {
 	// _mt.Println("\tAngarNet.findSilver()")
-	lstAngar := sf.СписПолучить()
+	lstAngar := сам.СписПолучить()
 	var strOut string
 	for _, strSilver := range lstAngar {
 		if strings.Contains(strSilver, `<img title="Серебро" `) {
@@ -344,25 +344,25 @@ func (sf *Ангар) сереброНайти() {
 		// log._rintf("ERRO AngarNet.findSilver(): silver(%v) not number, err=\n\t%v\n", strSilver, err)
 		return
 	}
-	sf.сереброВсего.Уст(iSilver)
+	сам.сереброВсего.Уст(iSilver)
 }
 
 // Ищет в теле текста ангара золото
-func (sf *Ангар) золотоНайти() {
+func (сам *Ангар) золотоНайти() {
 	var (
-		lstAngar = sf.бот.Ангар().СписПолучить()
+		lstAngar = сам.бот.Ангар().СписПолучить()
 		strOut   string
-		isFind   bool
+		iсамind  bool
 	)
 
 	for _, strGold := range lstAngar {
 		if strings.Contains(strGold, `<img title="Золото" `) {
 			strOut = strGold
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind {
+	if !iсамind {
 		return
 	}
 	// Выделить топливо
@@ -373,5 +373,5 @@ func (sf *Ангар) золотоНайти() {
 		// log._rintf("ERRO AngarNet.findGold(): gold(%v) not number, err=\n\t%v\n", strGold, err)
 		return
 	}
-	sf.бот.Ангар().Золото().Уст(iGold)
+	сам.бот.Ангар().Золото().Уст(iGold)
 }

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

@@ -85,7 +85,7 @@ func (сам *Оружейная) Пуск() error {
 
 // запускает обработку арсенала
 func (сам *Оружейная) пуск() {
-	// sf.getTime()
+	// сам.getTime()
 	time.Sleep(time.Second * 3)
 	фнРабота := func() {
 		defer time.Sleep(time.Minute * 5) // Интервал 5 минут (кратно интервалу производства -- от 40 минут до 1 часа)
@@ -108,7 +108,7 @@ func (сам *Оружейная) пуск() {
 		// 	if сам.РежимТекущ().Получ() == "upgrade" {
 		// 		continue
 		// 	}
-		// if err := sf.updateArsenal(); err != nil {
+		// if err := сам.updateArsenal(); err != nil {
 		// 	return fmt.Errorf("ArsenalNet.Run(): in update arsenal, err=\n\t%w", err)
 		// }
 		default:
@@ -408,16 +408,16 @@ func (сам *Оружейная) сделатьБронебойки() {
 	var (
 		strOut     string
 		lstArsenal = сам.СписПолучить()
-		isFind     bool
+		iсамind    bool
 	)
 	for ind, strArmor := range lstArsenal {
 		if strings.Contains(strArmor, `<span class="green2">Бронебойный снаряд</span><br/>`) {
 			strOut = lstArsenal[ind+10]
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind {
+	if !iсамind {
 		return
 	}
 	if strOut == `<div class="clrb"></div>` { // Уже запущено производство
@@ -443,18 +443,18 @@ func (сам *Оружейная) сделатьКумули() {
 	var (
 		strOut     string
 		lstArsenal = сам.СписПолучить()
-		isFind     bool
+		iсамind    bool
 		ind        int
 	)
 	for ind, strOut = range lstArsenal {
 		if strings.Contains(strOut, `<span class="green2">Кумулятивный снаряд</span><br/>`) {
 			ind += 10
 			strOut = lstArsenal[ind]
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind {
+	if !iсамind {
 		return
 	}
 	if !strings.Contains(strOut, `>Начать производство<`) {
@@ -477,18 +477,18 @@ func (сам *Оружейная) сдлатьФугасы() {
 	var (
 		lstArsenal = сам.СписПолучить()
 		strOut     = ""
-		isFind     bool
+		iсамind    bool
 		ind        int
 	)
 
 	for ind, strOut = range lstArsenal {
 		if strings.Contains(strOut, `<span class="green2">Фугасный снаряд</span><br/>`) {
 			strOut = lstArsenal[ind+10]
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind {
+	if !iсамind {
 		return
 	}
 	if !strings.Contains(strOut, `"><span><span>Начать производство</span></span></a>`) {
@@ -511,8 +511,8 @@ func (сам *Оружейная) сдлатьФугасы() {
 func (сам *Оружейная) сделатьРемку() bool {
 	// _mt.Println("\tArsenalNet.makeRemka()")
 	var (
-		strOut = ""
-		isFind bool
+		strOut  = ""
+		iсамind bool
 	)
 	lstArsenal, ош := сам.сеть.Клиент().Get("https://wartank.ru/production/Armory")
 	if ош != nil {
@@ -522,11 +522,11 @@ func (сам *Оружейная) сделатьРемку() bool {
 	// <a class="simple-but border" href="Armory?55-1.ILinkListener-productions-0-production-startProduceLink"><span><span>Начать производство</span></span></a>
 	for _, strOut = range lstArsenal {
 		if strings.Contains(strOut, `.ILinkListener-productions-0-production-startProduceLink`) {
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind {
+	if !iсамind {
 		return false
 	}
 	// Получить ссылку на ремку

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

@@ -23,9 +23,9 @@ func НовАрсеналСеть(arsenal types.ИАрсенал) (*ArsenalNet,
 		return nil, fmt.Errorf("NewArsenalNet(): in create SectionNet, err=\n\t%w", err)
 	}
 
-	sf := &ArsenalNet{
+	сам := &ArsenalNet{
 		СценаСеть: sectionNet,
 	}
 
-	return sf, nil
+	return сам, nil
 }

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

@@ -39,17 +39,17 @@ func НовБанк(база types.ИБаза) (*Банк, error) {
 		return nil, fmt.Errorf("НовБанк(): при создании статы серебра бота, ош=\n\t%w", ош)
 	}
 
-	sf := &Банк{
+	сам := &Банк{
 		Секция:     section,
 		сереброБот: сереброБот,
 		режим1:     bankmode.NewBankMode(),
 		режим2:     bankmode.NewBankMode(),
 	}
-	sf.сеть, ош = banknet.NewBankNet(sf)
+	сам.сеть, ош = banknet.NewBankNet(сам)
 	if ош != nil {
 		return nil, fmt.Errorf("NewBank(): in create NetBank, err=\n\t%w", ош)
 	}
-	return sf, nil
+	return сам, nil
 }
 
 // Пуск -- запускает банк в работу
@@ -94,7 +94,7 @@ func (сам *Банк) пуск() {
 
 	}
 	for {
-		// <-sf.ВремяОпрос().КаналСиг()
+		// <-сам.ВремяОпрос().КаналСиг()
 		fnRun()
 	}
 }
@@ -249,31 +249,31 @@ func (сам *Банк) построитьУлучшить() bool {
 }
 
 // РежимРаботы2 -- возвращает объект режима2
-func (sf *Банк) РежимРаботы2() types.ИБанкРежим {
-	return sf.режим2
+func (сам *Банк) РежимРаботы2() types.ИБанкРежим {
+	return сам.режим2
 }
 
 // РежимРаботы1 -- возвращает объект режима1
-func (sf *Банк) РежимРаботы1() types.ИБанкРежим {
-	return sf.режим1
+func (сам *Банк) РежимРаботы1() types.ИБанкРежим {
+	return сам.режим1
 }
 
 // СереброБот -- возвращает серебро от бота
-func (sf *Банк) СереброБот() types.ИСтатПарам {
-	return sf.сереброБот
+func (сам *Банк) СереброБот() types.ИСтатПарам {
+	return сам.сереброБот
 }
 
 // Запускает в производство серебро
-func (sf *Банк) сделатьСеребро() (alias.МилСек, error) {
+func (сам *Банк) сделатьСеребро() (alias.МилСек, error) {
 	var (
-		lstBank = sf.СписПолучить()
+		lstBank = сам.СписПолучить()
 		ind     int
 		strOut  string
 		strLink string
-		isFind  bool
+		iсамind bool
 	)
-	time1 := sf.РежимРаботы1().ВремяСделать()
-	time2 := sf.РежимРаботы2().ВремяСделать()
+	time1 := сам.РежимРаботы1().ВремяСделать()
+	time2 := сам.РежимРаботы2().ВремяСделать()
 	if time1 > time2 {
 		time1 = time2
 	}
@@ -281,16 +281,16 @@ func (sf *Банк) сделатьСеребро() (alias.МилСек, error) {
 		if strings.Contains(strOut, time1) {
 			ind += 7
 			strLink = lstBank[ind]
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if isFind && strings.Contains(strLink, `>Начать производство</span>`) {
+	if iсамind && strings.Contains(strLink, `>Начать производство</span>`) {
 		lstLink := strings.Split(strLink, `<a class="simple-but border" href="`)
 		strLink = lstLink[1]
 		lstLink = strings.Split(strLink, `"><span><span>Начать производство</span></span></a>`)
 		strLink = "https://wartank.ru/production/" + lstLink[0]
-		lstBank, err := sf.сеть.Get(strLink)
+		lstBank, err := сам.сеть.Get(strLink)
 		if err != nil {
 			return 0, fmt.Errorf("BankNet.makeProduct(): при выполнении GET-запроса начать производство, err=%w", err)
 		}
@@ -299,20 +299,20 @@ func (sf *Банк) сделатьСеребро() (alias.МилСек, error) {
 				return 30, nil
 			}
 		}
-		if err = sf.СтрОбновить(lstBank); err != nil {
+		if err = сам.СтрОбновить(lstBank); err != nil {
 			return 0, fmt.Errorf("BankNet.makeProduct(): при обновлении lstBank, err=%w", err)
 		}
-		if err := sf.Уст(alias.Время(time1)); err != nil {
+		if err := сам.Уст(alias.Время(time1)); err != nil {
 			log.Printf("WARN Банк.makeProduct(): при установке времени производства банка(%v)\n\terr=%v\n", time1, err)
 		}
 	}
-	return sf.ВремяОстат().ПолучМилСек(), nil
+	return сам.ВремяОстат().ПолучМилСек(), nil
 }
 
 // Получает все режимы банка
-func (sf *Банк) получитьВсеРежимы() error {
+func (сам *Банк) получитьВсеРежимы() error {
 	var (
-		lstBank  = sf.СписПолучить()
+		lstBank  = сам.СписПолучить()
 		ind      int
 		strMode  string
 		strMode1 string
@@ -333,10 +333,10 @@ func (sf *Банк) получитьВсеРежимы() error {
 		if err != nil {
 			return fmt.Errorf("BankNet.getAllMode(): numSilver1(%v) not number, err=\n\t%w", strMode1, err)
 		}
-		sf.РежимРаботы1().Серебро().Уст(iNum1)
+		сам.РежимРаботы1().Серебро().Уст(iNum1)
 		// Установить время производства
 		strTime1 := lstBank[ind+2]
-		sf.РежимРаботы1().ВремяСделатьУст(strTime1)
+		сам.РежимРаботы1().ВремяСделатьУст(strTime1)
 		if iNum1 <= 2 { // Если банк слишком слабый
 			return nil
 		}
@@ -358,10 +358,10 @@ func (sf *Банк) получитьВсеРежимы() error {
 		if err != nil {
 			return fmt.Errorf("BankNet.getAllMode(): numSilver2(%v) not number, err=\n\t%w", strMode2, err)
 		}
-		sf.РежимРаботы2().Серебро().Уст(iNum2)
+		сам.РежимРаботы2().Серебро().Уст(iNum2)
 		// Установить время производства
 		strTime2 := lstBank[ind+2]
-		sf.РежимРаботы2().ВремяСделатьУст(strTime2)
+		сам.РежимРаботы2().ВремяСделатьУст(strTime2)
 	}
 	return nil
 }

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

@@ -24,16 +24,16 @@ func NewBankMode() *BankMode {
 }
 
 // Серебро -- возвращает объект серебра режима
-func (sf *BankMode) Серебро() types.ИСтатПарам {
-	return sf.серебро
+func (сам *BankMode) Серебро() types.ИСтатПарам {
+	return сам.серебро
 }
 
 // ВремяСделать -- возвращает временя производства режима
-func (sf *BankMode) ВремяСделать() string {
-	return sf.timeCount
+func (сам *BankMode) ВремяСделать() string {
+	return сам.timeCount
 }
 
 // ВремяСделатьУст -- устанавливает время производства режима
-func (sf *BankMode) ВремяСделатьУст(val string) {
-	sf.timeCount = val
+func (сам *BankMode) ВремяСделатьУст(val string) {
+	сам.timeCount = val
 }

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

@@ -25,9 +25,9 @@ func NewBankNet(bank types.ИБанк) (*BankNet, error) {
 		return nil, fmt.Errorf("NewBankNet(): in create *SectionNet, err=\n\t%w", err)
 	}
 
-	sf := &BankNet{
+	сам := &BankNet{
 		СценаСеть: sectionNet,
 	}
 
-	return sf, nil
+	return сам, nil
 }

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

@@ -50,55 +50,55 @@ func НовБаза(ангар types.ИАнгар) (*База, error) {
 		return nil, fmt.Errorf("NewBase(): in create ISection, err=\n\t%w", err)
 	}
 	log.Printf("NewBase(): %q\n", section.Бот().Имя())
-	sf := &База{
+	сам := &База{
 		Секция: section,
 	}
 	{ // База в сети
-		sf.сеть, err = basenet.NewBaseNet(sf)
+		сам.сеть, err = basenet.NewBaseNet(сам)
 		if err != nil {
 			return nil, fmt.Errorf("NewBase(): in create NetBase, err=\n\t%w", err)
 		}
 	}
 	{ // Arsenal
-		sf.арсенал, err = arsenal.НовОружейная(sf)
+		сам.арсенал, err = arsenal.НовОружейная(сам)
 		if err != nil {
 			return nil, fmt.Errorf("NewBase(): in create IArsenal, err=\n\t%w", err)
 		}
 	}
 	{ // Bank
-		sf.банк, err = bank.НовБанк(sf)
+		сам.банк, err = bank.НовБанк(сам)
 		if err != nil {
 			return nil, fmt.Errorf("NewBase(): in create IBank, err=\n\t%w", err)
 		}
 	}
 	{ // Mine
-		sf.шахта, err = mine.НовШахта(sf)
+		сам.шахта, err = mine.НовШахта(сам)
 		if err != nil {
 			return nil, fmt.Errorf("NewBase(): in create IMine, err=\n\t%w", err)
 		}
 	}
 	{ // Market
-		sf.ранок, err = market.НовРынок(sf)
+		сам.ранок, err = market.НовРынок(сам)
 		if err != nil {
 			return nil, fmt.Errorf("NewBase(): при создании IMarket, err=\n\t%w", err)
 		}
 	}
 	{ // Polygon
-		sf.полигон, err = polygon.НовПолигон(sf)
+		сам.полигон, err = polygon.НовПолигон(сам)
 		if err != nil {
 			return nil, fmt.Errorf("NewBase(): in create IPolygon, err=\n\t%w", err)
 		}
 	}
-	return sf, nil
+	return сам, nil
 }
 
 // Запускает базу в обработку
-func (sf *База) Пуск() error {
+func (сам *База) Пуск() error {
 	log.Printf("Base.Run()\n")
-	if err := sf.runComponent(); err != nil {
+	if err := сам.runComponent(); err != nil {
 		return fmt.Errorf("Base.Run(): run, err=\n\t%w", err)
 	}
-	go sf.пуск()
+	go сам.пуск()
 	return nil
 }
 
@@ -122,7 +122,7 @@ func (сам *База) пуск() {
 		select {
 		case <-сам.Кнт().Done():
 			return
-		// case <-sf.ВремяОпрос().КаналСиг():
+		// case <-сам.ВремяОпрос().КаналСиг():
 		// 	фнЦикл()
 		default:
 			фнЦикл()
@@ -131,34 +131,34 @@ func (сам *База) пуск() {
 }
 
 // Запускает компоненты
-func (sf *База) runComponent() error {
+func (сам *База) runComponent() error {
 	log.Printf("Base.run()\n")
-	sf.блок.Lock()
-	defer sf.блок.Unlock()
-	if err := sf.арсенал.Пуск(); err != nil {
+	сам.блок.Lock()
+	defer сам.блок.Unlock()
+	if err := сам.арсенал.Пуск(); err != nil {
 		return fmt.Errorf("Base.run(): in run IArsenal, err=\n\t%w", err)
 	}
-	if err := sf.банк.Пуск(); err != nil {
+	if err := сам.банк.Пуск(); err != nil {
 		return fmt.Errorf("Base.run(): in run IBank, err=\n\t%w", err)
 	}
-	if err := sf.шахта.Пуск(); err != nil {
+	if err := сам.шахта.Пуск(); err != nil {
 		return fmt.Errorf("Base.run(): in run IMine, err=\n\t%w", err)
 	}
-	if err := sf.ранок.Пуск(); err != nil {
+	if err := сам.ранок.Пуск(); err != nil {
 		return fmt.Errorf("Base.run(): in run IMarket, err=\n\t%w", err)
 	}
-	if err := sf.полигон.Пуск(); err != nil {
+	if err := сам.полигон.Пуск(); err != nil {
 		return fmt.Errorf("Base.run(): in run IPolygon, err=\n\t%w", err)
 	}
 	return nil
 }
 
 // Выбирает время обновления базы по компонентам
-func (sf *База) setCountDown() {
-	timeBase := sf.банк.ВремяОстат().String()
+func (сам *База) setCountDown() {
+	timeBase := сам.банк.ВремяОстат().String()
 	timeCount := timeBase
-	timeArsenal := sf.арсенал.ВремяОстат().String()
-	timeMine := sf.шахта.ВремяОстат().String()
+	timeArsenal := сам.арсенал.ВремяОстат().String()
+	timeMine := сам.шахта.ВремяОстат().String()
 	if timeArsenal < timeCount {
 		timeCount = timeArsenal
 	}
@@ -166,61 +166,61 @@ func (sf *База) setCountDown() {
 		timeCount = timeMine
 	}
 	if timeCount <= "05" {
-		sf.времОстат = 5
+		сам.времОстат = 5
 		return
 	}
 	if timeCount > "00:10:00" {
-		sf.времОстат = 600
+		сам.времОстат = 600
 	}
-	sf.Секция.ОбратВремяУст(alias.Время(timeCount))
+	сам.Секция.ОбратВремяУст(alias.Время(timeCount))
 }
 
 // Арсенал -- возвращает объект арсенала
-func (sf *База) Арсенал() types.ИАрсенал {
-	return sf.арсенал
+func (сам *База) Арсенал() types.ИАрсенал {
+	return сам.арсенал
 }
 
 // Банк -- возвращает объект банка
-func (sf *База) Банк() types.ИБанк {
-	sf.блок.Lock()
-	defer sf.блок.Unlock()
-	return sf.банк
+func (сам *База) Банк() types.ИБанк {
+	сам.блок.Lock()
+	defer сам.блок.Unlock()
+	return сам.банк
 }
 
 // Полигон -- возвращает объект полигона
-func (sf *База) Полигон() types.ИБазаПолигон {
-	return sf.полигон
+func (сам *База) Полигон() types.ИБазаПолигон {
+	return сам.полигон
 }
 
 // Шахта -- возвращает объект шахты
-func (sf *База) Шахта() types.ИБазаШахта {
-	return sf.шахта
+func (сам *База) Шахта() types.ИБазаШахта {
+	return сам.шахта
 }
 
 // Рынок -- возвращает объект рынка
-func (sf *База) Рынок() types.ИРынок {
-	return sf.ранок
+func (сам *База) Рынок() types.ИРынок {
+	return сам.ранок
 }
 
 // Проверяет на забрать шахту
-func (sf *База) проверитьШахту() {
-	if sf.шахта.Руда().Получ() == 0 {
-		sf.шахтаСтатаОбновить()
+func (сам *База) проверитьШахту() {
+	if сам.шахта.Руда().Получ() == 0 {
+		сам.шахтаСтатаОбновить()
 	}
-	sf.шахтаАпгрейдФорсаж() // Нужно ли ускорить апгрейд шахты
-	if sf.шахта.СценаРежим().Режим() == "upgrade" {
+	сам.шахтаАпгрейдФорсаж() // Нужно ли ускорить апгрейд шахты
+	if сам.шахта.СценаРежим().Режим() == "upgrade" {
 		return
 	}
-	sf.шахтаСтатаОбновить()
-	sf.checkMineTime()
+	сам.шахтаСтатаОбновить()
+	сам.checkMineTime()
 }
 
 // Проверяет время ожидания шахты
-func (sf *База) checkMineTime() {
+func (сам *База) checkMineTime() {
 	var (
-		lstBase = sf.СписПолучить()
+		lstBase = сам.СписПолучить()
 		strOut  string
-		isFind  bool
+		iсамind bool
 		ind     int
 	)
 	for ind, strOut = range lstBase {
@@ -229,10 +229,10 @@ func (sf *База) checkMineTime() {
 		}
 		ind += 11
 		strOut = lstBase[ind]
-		isFind = true
+		iсамind = true
 		break
 	}
-	if !isFind {
+	if !iсамind {
 		return
 	}
 	if !strings.Contains(strOut, `<td><div class="value-block lh1"><span><span>`) {
@@ -242,27 +242,27 @@ func (sf *База) checkMineTime() {
 	strTime := lstTime[1]
 	lstTime = strings.Split(strTime, `</span></span></div></td>`)
 	strTime = lstTime[0]
-	if err := sf.шахта.Уст(alias.Время(strTime)); err != nil {
+	if err := сам.шахта.Уст(alias.Время(strTime)); err != nil {
 		log.Printf("ERRO Base.checkMineTime(): при установке обратного отсчёта(%v), err=\n\t%v\n", strTime, err)
 	}
 }
 
 // Проверка статистики шахты
-func (sf *База) шахтаСтатаОбновить() {
+func (сам *База) шахтаСтатаОбновить() {
 	var (
-		lstMine = sf.СписПолучить()
+		lstMine = сам.СписПолучить()
 		strOut  string
-		isFind  bool
+		iсамind bool
 		ind     int
 	)
 	{ // Ищем руду
 		for _, strOut = range lstMine {
 			if strings.Contains(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/ore.png?2" alt="Руда" title="Руда"/>`) {
-				isFind = true
+				iсамind = true
 				break
 			}
 		}
-		if isFind && strings.Contains(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/ore.png?2" alt="Руда" title="Руда"/> `) {
+		if iсамind && strings.Contains(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/ore.png?2" alt="Руда" title="Руда"/> `) {
 			lstRuda := strings.Split(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/ore.png?2" alt="Руда" title="Руда"/> `)
 			strRuda := lstRuda[1]
 			lstRuda = strings.Split(strRuda, ` &nbsp;&nbsp;</span>`)
@@ -272,17 +272,17 @@ func (sf *База) шахтаСтатаОбновить() {
 				log.Printf("ERRO Base.checkMineStat(): руда(%v) не число, err=\n\t%v\n", strRuda, err)
 				return
 			}
-			sf.шахта.Руда().Уст(iRuda)
+			сам.шахта.Руда().Уст(iRuda)
 		}
 	}
 	{ // Ищем железо
 		for _, strOut = range lstMine {
 			if strings.Contains(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/iron.png?2" alt="Железо" title="Железо"/> `) {
-				isFind = true
+				iсамind = true
 				break
 			}
 		}
-		if isFind && strings.Contains(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/iron.png?2" alt="Железо" title="Железо"/> `) {
+		if iсамind && strings.Contains(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/iron.png?2" alt="Железо" title="Железо"/> `) {
 			lstFerrum := strings.Split(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/iron.png?2" alt="Железо" title="Железо"/> `)
 			strFerrum := lstFerrum[1]
 			lstFerrum = strings.Split(strFerrum, ` &nbsp;&nbsp;</span>`)
@@ -292,17 +292,17 @@ func (sf *База) шахтаСтатаОбновить() {
 				log.Printf("ERRO Base.checkMineStat(): железо(%v) не число, err=\n\t%v\n", strFerrum, err)
 				return
 			}
-			sf.шахта.Железо().Уст(iFerrum)
+			сам.шахта.Железо().Уст(iFerrum)
 		}
 	}
 	{ // Ищем сталь
 		for _, strOut = range lstMine {
 			if strings.Contains(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/steel.png?2" alt="Сталь" title="Сталь"/> `) {
-				isFind = true
+				iсамind = true
 				break
 			}
 		}
-		if isFind && strings.Contains(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/steel.png?2" alt="Сталь" title="Сталь"/> `) {
+		if iсамind && strings.Contains(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/steel.png?2" alt="Сталь" title="Сталь"/> `) {
 			lstSteel := strings.Split(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/steel.png?2" alt="Сталь" title="Сталь"/> `)
 			strSteel := lstSteel[1]
 			lstSteel = strings.Split(strSteel, ` &nbsp;&nbsp;</span>`)
@@ -312,17 +312,17 @@ func (sf *База) шахтаСтатаОбновить() {
 				log.Printf("ERRO Base.checkMineStat(): сталь(%v) не число, err=\n\t%v\n", strSteel, err)
 				return
 			}
-			sf.шахта.Сталь().Уст(iSteel)
+			сам.шахта.Сталь().Уст(iSteel)
 		}
 	}
 	{ // Ищем свинец
 		for _, strOut = range lstMine {
 			if strings.Contains(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/plumbum.png?2" alt="Свинец" title="Свинец"/> `) {
-				isFind = true
+				iсамind = true
 				break
 			}
 		}
-		if isFind && strings.Contains(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/plumbum.png?2" alt="Свинец" title="Свинец"/> `) {
+		if iсамind && strings.Contains(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/plumbum.png?2" alt="Свинец" title="Свинец"/> `) {
 			lstPlumbum := strings.Split(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/plumbum.png?2" alt="Свинец" title="Свинец"/> `)
 			strPlumbum := lstPlumbum[1]
 			lstPlumbum = strings.Split(strPlumbum, ` &nbsp;&nbsp;</span>`)
@@ -332,25 +332,25 @@ func (sf *База) шахтаСтатаОбновить() {
 				log.Printf("ERRO Base.checkMineStat(): свинец(%v) не число, err=\n\t%v\n", strPlumbum, err)
 				return
 			}
-			sf.шахта.Свинец().Уст(iPlumbum)
+			сам.шахта.Свинец().Уст(iPlumbum)
 		}
 	}
 	{ // Ищем время обработки и режим
-		lstBase := sf.СписПолучить()
+		lstBase := сам.СписПолучить()
 		for ind, strOut = range lstBase {
 			if strings.Contains(strOut, `<span class="green2">Шахта - `) {
-				isFind = true
+				iсамind = true
 				ind += 11
 				strOut = lstBase[ind]
 				break
 			}
 		}
-		if isFind && strings.Contains(strOut, `<td><div class="value-block lh1"><span><span>`) {
+		if iсамind && strings.Contains(strOut, `<td><div class="value-block lh1"><span><span>`) {
 			lstTime := strings.Split(strOut, `<td><div class="value-block lh1"><span><span>`)
 			strTime := lstTime[1]
 			lstTime = strings.Split(strTime, `</span></span></div></td>`)
 			strTime = lstTime[0]
-			if err := sf.шахта.Уст(alias.Время(strTime)); err != nil {
+			if err := сам.шахта.Уст(alias.Время(strTime)); err != nil {
 				log.Printf("ERRO Base.checkMineStat(): при установке времени ожидания шахты(%v)\n\terr=%v\n", strTime, err)
 			}
 		}
@@ -368,53 +368,53 @@ func (sf *База) шахтаСтатаОбновить() {
 			lstNum = strings.Split(strNum, `</div></td>`)
 			strNum = lstNum[0]
 			работа := alias.СценаРабота("Железо-" + strNum)
-			sf.шахта.СценаРежим().РаботаУст(работа)
+			сам.шахта.СценаРежим().РаботаУст(работа)
 		case strings.Contains(strOut, `/images/icons/ore.png`): // Руда
 			lstNum := strings.Split(strOut, `<td class="vam"><div class="nwr pr5 gray1"><img class="rico vm" src="/images/icons/ore.png?2" alt="ore"/>&nbsp;`)
 			strNum := lstNum[1]
 			lstNum = strings.Split(strNum, `</div></td>`)
 			strNum = lstNum[0]
 			работа := alias.СценаРабота("Руда-" + strNum)
-			sf.шахта.СценаРежим().РаботаУст(работа)
+			сам.шахта.СценаРежим().РаботаУст(работа)
 		case strings.Contains(strOut, `/images/icons/steel.png`): // Руда
 			lstNum := strings.Split(strOut, `<td class="vam"><div class="nwr pr5 gray1"><img class="rico vm" src="/images/icons/steel.png?2" alt="steel"/>&nbsp;`)
 			strNum := lstNum[1]
 			lstNum = strings.Split(strNum, `</div></td>`)
 			strNum = lstNum[0]
 			работа := alias.СценаРабота("Сталь-" + strNum)
-			sf.шахта.СценаРежим().РаботаУст(работа)
+			сам.шахта.СценаРежим().РаботаУст(работа)
 		}
 	}
 }
 
 // Проверяет режимы арсенала
-func (sf *База) проверитьАрсенал() {
-	// countTime := sf.арсенал.ВремяОпрос().Получ()
+func (сам *База) проверитьАрсенал() {
+	// countTime := сам.арсенал.ВремяОпрос().Получ()
 	// if countTime > 3 {
 	// 	return
 	// }
-	if err := sf.арсенал.СтатаОбновить(); err != nil {
+	if err := сам.арсенал.СтатаОбновить(); err != nil {
 		// log._rintf("ERRO Base.checkArsenal(): при обновлении арсенала, err=\n\t%v\n", err)
 		return
 	}
-	if работа := sf.арсенал.СценаРежим().Работа(); работа == "" {
-		sf.проверитьАрсеналРежим()
+	if работа := сам.арсенал.СценаРежим().Работа(); работа == "" {
+		сам.проверитьАрсеналРежим()
 	}
-	sf.проверитьАрсеналУскорение() // Нужно ли ускорить апгрейд арсенала
-	if sf.арсенал.СценаРежим().Режим() == cons.РежимАпгрейд {
+	сам.проверитьАрсеналУскорение() // Нужно ли ускорить апгрейд арсенала
+	if сам.арсенал.СценаРежим().Режим() == cons.РежимАпгрейд {
 		return
 	}
-	sf.проверитьАрсеналВремя()
-	sf.проверитьАрсеналРежим()
+	сам.проверитьАрсеналВремя()
+	сам.проверитьАрсеналРежим()
 }
 
 // Проверяет время готовности арсенала
-func (sf *База) проверитьАрсеналВремя() {
+func (сам *База) проверитьАрсеналВремя() {
 	var (
-		lstBase = sf.СписПолучить()
+		lstBase = сам.СписПолучить()
 		ind     int
 		strOut  string
-		isFind  bool
+		iсамind bool
 	)
 	for ind, strOut = range lstBase {
 		if !strings.Contains(strOut, `Производит снаряды, ремкомплекты<br/>`) {
@@ -422,10 +422,10 @@ func (sf *База) проверитьАрсеналВремя() {
 		}
 		ind += 10
 		strOut = lstBase[ind]
-		isFind = true
+		iсамind = true
 		break
 	}
-	if !isFind {
+	if !iсамind {
 		return
 	}
 	if !strings.Contains(strOut, ":") {
@@ -438,126 +438,126 @@ func (sf *База) проверитьАрсеналВремя() {
 	strTime := lstTime[1]
 	lstTime = strings.Split(strTime, `</span></span></div></td>`)
 	strTime = lstTime[0]
-	if err := sf.арсенал.Уст(alias.Время(strTime)); err != nil {
+	if err := сам.арсенал.Уст(alias.Время(strTime)); err != nil {
 		log.Printf("ERRO Base.checkArsenalTime(): при установке времени ожидания арсенала(%v)\n\terr=%v\n", strTime, err)
 	}
 }
 
 // Проверяет режим производства арсенала
-func (sf *База) проверитьАрсеналРежим() {
+func (сам *База) проверитьАрсеналРежим() {
 	var (
 		strOut  string
-		lstBase = sf.СписПолучить()
+		lstBase = сам.СписПолучить()
 	)
 	for _, strOut = range lstBase {
 		if strings.Contains(strOut, `HollowCharge.png`) {
-			sf.арсенал.СценаРежим().РежимУст("кумулятивы")
+			сам.арсенал.СценаРежим().РежимУст("кумулятивы")
 			return
 		}
 		if strings.Contains(strOut, `ArmorPiercing.png`) {
-			sf.арсенал.СценаРежим().РежимУст("бронебойки")
+			сам.арсенал.СценаРежим().РежимУст("бронебойки")
 			return
 		}
 		if strings.Contains(strOut, `HighExplosive.png`) {
-			sf.арсенал.СценаРежим().РежимУст("фугасы")
+			сам.арсенал.СценаРежим().РежимУст("фугасы")
 			return
 		}
 		if strings.Contains(strOut, `repairkit.gif`) {
-			sf.арсенал.СценаРежим().РежимУст("ремки")
+			сам.арсенал.СценаРежим().РежимУст("ремки")
 			return
 		}
 	}
 }
 
 // Проверяет на ускорение апгрейда арсенала
-func (sf *База) проверитьАрсеналУскорение() {
+func (сам *База) проверитьАрсеналУскорение() {
 	var (
 		ind     int
 		strOut  = ""
-		isFind  bool
-		lstBase = sf.СписПолучить()
+		iсамind bool
+		lstBase = сам.СписПолучить()
 	)
 	{ // Проверка на платное ускорение апгрейда + время
 		for ind, strOut = range lstBase {
 			if strings.Contains(strOut, `Производит снаряды, ремкомплекты<br/>`) {
 				// Убедиться что есть строка платного ускорения
-				isFind = true
+				iсамind = true
 				ind += 29
 				strOut = lstBase[ind]
 				break
 			}
 		}
-		if !isFind {
+		if !iсамind {
 			return
 		}
 		{ // Платное ускорение
 			if strings.Contains(strOut, `Ускорить за`) {
-				if err := sf.арсенал.ОбратВремяУст(времОжидПлат); err != nil {
+				if err := сам.арсенал.ОбратВремяУст(времОжидПлат); err != nil {
 					log.Printf("WARN Base.checkArsenalForce(): при установке платного времени ускорения апгрейда арсенала(%v)\n\terr=%v\n", времОжидПлат, err)
 				}
-				sf.арсенал.СценаРежим().РаботаУст("апгрейд")
-				sf.арсенал.СценаРежим().РежимУст(cons.РежимАпгрейд)
+				сам.арсенал.СценаРежим().РаботаУст("апгрейд")
+				сам.арсенал.СценаРежим().РежимУст(cons.РежимАпгрейд)
 				return
 			}
 		}
 	}
 	{ // Проверка на бесплатное ускорение апгрейда
-		isFind = false
+		iсамind = false
 		for ind, strOut = range lstBase {
 			if strings.Contains(strOut, `Производит снаряды, ремкомплекты<br/>`) {
 				// Убедиться что есть строка платного ускорения
-				isFind = true
+				iсамind = true
 				ind += 26
 				strOut = lstBase[ind]
 				break
 			}
 		}
-		if !isFind {
+		if !iсамind {
 			return
 		}
 		if !strings.Contains(strOut, `>Ускорение<`) {
 			return
 		}
-		sf.арсенал.СценаРежим().РежимУст(cons.РежимАпгрейд)
+		сам.арсенал.СценаРежим().РежимУст(cons.РежимАпгрейд)
 		lstLink := strings.Split(strOut, `<td style="width:50%;padding-left:1px;"><a class="simple-but border" href="`)
 		strLink := lstLink[1]
 		lstLink = strings.Split(strLink, `"><span><span>Ускорение</span></span></a>`)
 		strLink = "https://wartank.ru/" + lstLink[0]
-		lstBase, err := sf.сеть.Get(strLink)
+		lstBase, err := сам.сеть.Get(strLink)
 		if err != nil {
 			// log._rintf("ERRO NetBank.checkArsenalForce(): при GET-запросе на бесплатном ускорении апгрейда арсенала, err=\n\t%v\n", err)
 			return
 		}
 		// sound.ArsenalForce()
-		if err := sf.СтрОбновить(lstBase); err != nil {
+		if err := сам.СтрОбновить(lstBase); err != nil {
 			// log._rintf("ERRO NetBank.checkArsenalForce(): при обновлении lstBase, err=\n\t%v\n", err)
 			return
 		}
-		sf.арсенал.СценаРежим().РаботаУст("апгрейд")
-		sf.арсенал.СценаРежим().РежимУст(cons.РежимАпгрейд)
-		if err := sf.арсенал.ОбратВремяУст(времОжидБесплат); err != nil {
+		сам.арсенал.СценаРежим().РаботаУст("апгрейд")
+		сам.арсенал.СценаРежим().РежимУст(cons.РежимАпгрейд)
+		if err := сам.арсенал.ОбратВремяУст(времОжидБесплат); err != nil {
 			log.Printf("WARN Base.checkArsenalForce(): при установке бесплатного времени ускорения апгрейда арсенала(%v)\n\terr=%v\n", времОжидБесплат, err)
 		}
 	}
 	// Все проверки прошли -- это просто работа
-	sf.арсенал.СценаРежим().РежимУст(cons.РежимРабота)
+	сам.арсенал.СценаРежим().РежимУст(cons.РежимРабота)
 }
 
 // Проверяет режим банка
-func (sf *База) проверитьБанк() error {
-	if sf.банк.СценаРежим().Работа() == "" {
-		sf.checkBankMode()
+func (сам *База) проверитьБанк() error {
+	if сам.банк.СценаРежим().Работа() == "" {
+		сам.checkBankMode()
 	}
-	sf.checkBankTime() // Проверка времени ожидания
-	countTime := sf.банк.ВремяОстат().ПолучМилСек()
+	сам.checkBankTime() // Проверка времени ожидания
+	countTime := сам.банк.ВремяОстат().ПолучМилСек()
 	if countTime > 5_000 {
 		return nil
 	}
-	sf.checkBankForce() // Нужно ли ускорить апгрейд банка
-	if sf.банк.СценаРежим().Режим() == cons.РежимАпгрейд {
+	сам.checkBankForce() // Нужно ли ускорить апгрейд банка
+	if сам.банк.СценаРежим().Режим() == cons.РежимАпгрейд {
 		return nil
 	}
-	sf.checkBankProduct() // Запуск производства в  банке
+	сам.checkBankProduct() // Запуск производства в  банке
 	return nil
 }
 
@@ -565,16 +565,16 @@ func (sf *База) проверитьБанк() error {
 func (сам *База) checkBankMode() {
 	var (
 		strOut  string
-		isFind  bool
+		iсамind bool
 		lstBase = сам.СписПолучить()
 	)
 	for _, strOut = range lstBase {
 		if strings.Contains(strOut, `<td class="vam"><div class="nwr pr5 gray1"><img class="rico vm" src="/images/icons/silver.png?2" alt="silver"/>&nbsp;`) {
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind {
+	if !iсамind {
 		return
 	}
 	lstSilver := strings.Split(strOut, `<td class="vam"><div class="nwr pr5 gray1"><img class="rico vm" src="/images/icons/silver.png?2" alt="silver"/>&nbsp;`)
@@ -587,22 +587,22 @@ func (сам *База) checkBankMode() {
 }
 
 // Проверяет на время ожидания банка
-func (sf *База) checkBankTime() {
+func (сам *База) checkBankTime() {
 	var (
 		strOut  string
 		ind     int
-		isFind  bool
-		lstBase = sf.СписПолучить()
+		iсамind bool
+		lstBase = сам.СписПолучить()
 	)
 	for ind, strOut = range lstBase {
 		if strings.Contains(strOut, `Производит серебро<br/>`) {
-			isFind = true
+			iсамind = true
 			ind += 10
 			strOut = lstBase[ind]
 			break
 		}
 	}
-	if !isFind {
+	if !iсамind {
 		return
 	}
 	if !strings.Contains(strOut, `<td><div class="value-block lh1"><span><span>`) {
@@ -612,46 +612,46 @@ func (sf *База) checkBankTime() {
 	strTime := lstTime[1]
 	lstTime = strings.Split(strTime, `</span></span></div></td>`)
 	strTime = lstTime[0]
-	if err := sf.банк.Уст(alias.Время(strTime)); err != nil {
+	if err := сам.банк.Уст(alias.Время(strTime)); err != nil {
 		log.Printf("ERRO Base.checkBankTime(): при установке времени ожидания банка(%v)\n\terr=%v\n", strTime, err)
 	}
 }
 
 // Проверяет на произвести в банке
-func (sf *База) checkBankProduct() {
+func (сам *База) checkBankProduct() {
 	var (
 		strOut  string
 		ind     int
-		isFind  bool
-		lstBase = sf.СписПолучить()
+		iсамind bool
+		lstBase = сам.СписПолучить()
 	)
 	for ind, strOut = range lstBase {
 		if strings.Contains(strOut, `Производит серебро<br/>`) {
-			isFind = true
+			iсамind = true
 			ind += 11
 			strOut = lstBase[ind]
 			break
 		}
 	}
-	if !isFind {
+	if !iсамind {
 		return
 	}
 	if !strings.Contains(strOut, `>Производство</span>`) {
 		return
 	}
-	sf.банк.UpdateLst()
-	sf.банк.ОбратВремяУст("01:00")
+	сам.банк.UpdateLst()
+	сам.банк.ОбратВремяУст("01:00")
 }
 
 // Проверка получения серебра из банка
 
 // Проверяет на ускорение апгрейда банка
-func (sf *База) checkBankForce() {
+func (сам *База) checkBankForce() {
 	var (
 		ind     int
 		strOut  = ""
 		isOut   bool
-		lstBase = sf.СписПолучить()
+		lstBase = сам.СписПолучить()
 	)
 	{ // Проверка на платное ускорение апгрейда
 		for ind, strOut = range lstBase {
@@ -664,11 +664,11 @@ func (sf *База) checkBankForce() {
 			}
 		}
 		if isOut && strings.Contains(strOut, `Ускорить за`) {
-			if err := sf.банк.ОбратВремяУст(времОжидПлат); err != nil {
+			if err := сам.банк.ОбратВремяУст(времОжидПлат); err != nil {
 				log.Printf("WARN Base.checkBankForce(): при установке времени ожидания платного ускорения апгрейда банка(%v)\n\terr=%v\n", времОжидПлат, err)
 			}
-			sf.банк.СценаРежим().РаботаУст("апгрейд")
-			sf.банк.СценаРежим().РежимУст(cons.РежимАпгрейд)
+			сам.банк.СценаРежим().РаботаУст("апгрейд")
+			сам.банк.СценаРежим().РежимУст(cons.РежимАпгрейд)
 			return
 		}
 	}
@@ -689,18 +689,18 @@ func (sf *База) checkBankForce() {
 			strLink := lstLink[1]
 			lstLink = strings.Split(strLink, `"><span><span>Ускорение</span></span></a>`)
 			strLink = "https://wartank.ru/" + lstLink[0]
-			lstBase, err := sf.сеть.Get(strLink)
+			lstBase, err := сам.сеть.Get(strLink)
 			if err != nil {
 				// log._rintf("ERRO NetBank.checkBankForce(): при GET-запросе на бесплатном ускорении апгрейда банка, err=\n\t%v\n", err)
 				return
 			}
-			if err := sf.СтрОбновить(lstBase); err != nil {
+			if err := сам.СтрОбновить(lstBase); err != nil {
 				// log._rintf("ERRO NetBank.checkBankForce(): при обновлении lstBase, err=\n\t%v\n", err)
 				return
 			}
-			sf.банк.СценаРежим().РаботаУст("апгрейд")
-			sf.банк.СценаРежим().РежимУст(cons.РежимАпгрейд)
-			if err := sf.банк.ОбратВремяУст(времОжидБесплат); err != nil {
+			сам.банк.СценаРежим().РаботаУст("апгрейд")
+			сам.банк.СценаРежим().РежимУст(cons.РежимАпгрейд)
+			if err := сам.банк.ОбратВремяУст(времОжидБесплат); err != nil {
 				log.Printf("WARN Base.checkBankForce(): при установке времени бесплатного ускорения агрейда банка(%v)\n\terr=%v\n", времОжидБесплат, err)
 			}
 		}
@@ -708,12 +708,12 @@ func (sf *База) checkBankForce() {
 }
 
 // Проверяет на ускорение апгрейда шахты
-func (sf *База) шахтаАпгрейдФорсаж() {
+func (сам *База) шахтаАпгрейдФорсаж() {
 	var (
 		ind     int
 		strOut  = ""
 		isOut   bool
-		lstBase = sf.СписПолучить()
+		lstBase = сам.СписПолучить()
 	)
 	{ // Проверка на платное ускорение апгрейда
 		for ind, strOut = range lstBase {
@@ -726,9 +726,9 @@ func (sf *База) шахтаАпгрейдФорсаж() {
 			}
 		}
 		if isOut && strings.Contains(strOut, `Ускорить за`) {
-			sf.шахта.СценаРежим().РаботаУст("апгрейд")
-			sf.шахта.СценаРежим().РежимУст(cons.РежимАпгрейд)
-			if err := sf.шахта.ОбратВремяУст(времОжидПлат); err != nil {
+			сам.шахта.СценаРежим().РаботаУст("апгрейд")
+			сам.шахта.СценаРежим().РежимУст(cons.РежимАпгрейд)
+			if err := сам.шахта.ОбратВремяУст(времОжидПлат); err != nil {
 				log.Printf("WARN Base.checkMineForce(): при установке времени платного апгрейда шахты(%v)\n\terr=%v\n", времОжидПлат, err)
 			}
 			return
@@ -750,37 +750,37 @@ func (sf *База) шахтаАпгрейдФорсаж() {
 			strLink := lstLink[1]
 			lstLink = strings.Split(strLink, `"><span><span>Ускорение</span></span></a>`)
 			strLink = "https://wartank.ru/" + lstLink[0]
-			lstBase, err := sf.сеть.Get(strLink)
+			lstBase, err := сам.сеть.Get(strLink)
 			if err != nil {
 				// log._rintf("ERRO NetBank.checkMineForce(): при GET-запросе на бесплатном ускорении апгрейда шахты, err=\n\t%v\n", err)
 				return
 			}
-			if err := sf.СтрОбновить(lstBase); err != nil {
+			if err := сам.СтрОбновить(lstBase); err != nil {
 				// log._rintf("ERRO NetBank.checkMineForce(): при обновлении lstBase, err=\n\t%v\n", err)
 				return
 			}
-			if err := sf.шахта.ОбратВремяУст(времОжидБесплат); err != nil {
+			if err := сам.шахта.ОбратВремяУст(времОжидБесплат); err != nil {
 				log.Printf("WARN Base.checkMineForce(): при установке времени апгрейда шахты(%v)\n\terr=%v\n", времОжидБесплат, err)
 			}
 			// sound.MineForce()
-			sf.шахта.СценаРежим().РаботаУст("апгрейд")
-			sf.шахта.СценаРежим().РежимУст(cons.РежимАпгрейд)
+			сам.шахта.СценаРежим().РаботаУст("апгрейд")
+			сам.шахта.СценаРежим().РежимУст(cons.РежимАпгрейд)
 			return
 		}
 	}
 	// Все проверки прошли -- это просто работа
-	sf.шахта.СценаРежим().РежимУст(cons.РежимРабота)
+	сам.шахта.СценаРежим().РежимУст(cons.РежимРабота)
 }
 
 // Проверяет на ускорение апгрейда полигона
-func (sf *База) проверитьПолигонУсиление() {
+func (сам *База) проверитьПолигонУсиление() {
 	var (
 		ind     int
 		strOut  = ""
 		isOut   bool
-		lstBase = sf.СписПолучить()
+		lstBase = сам.СписПолучить()
 	)
-	countTime := sf.полигон.ВремяОстат().ПолучМилСек()
+	countTime := сам.полигон.ВремяОстат().ПолучМилСек()
 	if countTime > 3_000 {
 		return
 	}
@@ -800,12 +800,12 @@ func (sf *База) проверитьПолигонУсиление() {
 			// strTime = lstTime[1]
 			// lstTime = strings.Split(strTime, `</span></span></div></td>`)
 			// strTime = lstTime[0]
-			// if err := sf.polygon.CountDown().Set(strTime); err != nil {
+			// if err := сам.polygon.CountDown().Set(strTime); err != nil {
 			// 	// log._rintf("WARN Base.checkMineForce(): при установке времени апгрейда полигона(%v)\n\terr=%v\n", strTime, err)
 			// }
-			sf.полигон.СценаРежим().РаботаУст("апгрейд")
-			sf.полигон.СценаРежим().РежимУст(cons.РежимАпгрейд)
-			if err := sf.полигон.ОбратВремяУст(времОжидПлат); err != nil {
+			сам.полигон.СценаРежим().РаботаУст("апгрейд")
+			сам.полигон.СценаРежим().РежимУст(cons.РежимАпгрейд)
+			if err := сам.полигон.ОбратВремяУст(времОжидПлат); err != nil {
 				log.Printf("WARN Base.checkPolygonForce(): при установке платного времени апгрейда полигона(%v)\n\terr=%v\n", времОжидПлат, err)
 			}
 			return
@@ -827,20 +827,20 @@ func (sf *База) проверитьПолигонУсиление() {
 			strLink := lstLink[1]
 			lstLink = strings.Split(strLink, `"><span><span>Ускорение</span></span></a>`)
 			strLink = "https://wartank.ru/" + lstLink[0]
-			lstBase, err := sf.сеть.Get(strLink)
+			lstBase, err := сам.сеть.Get(strLink)
 			if err != nil {
 				// log._rintf("ERRO NetBank.checkPolygonForce(): при GET-запросе на бесплатном ускорении апгрейда полигона, err=\n\t%v\n", err)
 				return
 			}
-			if err := sf.СтрОбновить(lstBase); err != nil {
+			if err := сам.СтрОбновить(lstBase); err != nil {
 				// log._rintf("ERRO NetBank.checkPolygonForce(): при обновлении lstBase, err=\n\t%v\n", err)
 				return
 			}
 			// sound.MineForce()
-			sf.полигон.СценаРежим().РаботаУст("апгрейд")
-			sf.полигон.СценаРежим().РежимУст(cons.РежимАпгрейд)
+			сам.полигон.СценаРежим().РаботаУст("апгрейд")
+			сам.полигон.СценаРежим().РежимУст(cons.РежимАпгрейд)
 			// Установить время ожидания для обновления
-			if err := sf.полигон.ОбратВремяУст(времОжидБесплат); err != nil {
+			if err := сам.полигон.ОбратВремяУст(времОжидБесплат); err != nil {
 				log.Printf("WARN Base.checkPolygonForce(): при установке времени бесплатного апгрейда полигона(%v)\n\terr=%v\n", времОжидБесплат, err)
 			}
 			// log._rintf("INFO NetBank.checkPolygonForce(): ускорено строительство полигона\n")
@@ -848,5 +848,5 @@ func (sf *База) проверитьПолигонУсиление() {
 		}
 	}
 	// Все проверки прошли -- это просто работа
-	sf.полигон.СценаРежим().РежимУст(cons.РежимРабота)
+	сам.полигон.СценаРежим().РежимУст(cons.РежимРабота)
 }

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

@@ -25,9 +25,9 @@ func NewBaseNet(base types.ИБаза) (*BaseNet, error) {
 		return nil, fmt.Errorf("NewBaseNet(): in create SectionNet, err=\n\t%w", err)
 	}
 
-	sf := &BaseNet{
+	сам := &BaseNet{
 		СценаСеть: sectionNet,
 		strUrl:    strUrl,
 	}
-	return sf, nil
+	return сам, nil
 }

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

@@ -29,17 +29,17 @@ func НовРынок(база types.ИБаза) (*Рынок, error) {
 	if err != nil {
 		return nil, fmt.Errorf("NewMarket(): in create *Section, err=\n\t%w", err)
 	}
-	sf := &Рынок{
+	сам := &Рынок{
 		Секция: section,
 		бот:    база.Бот(),
 	}
 	{ // Маркет
-		sf.сеть, err = marketnet.NewMarketNet(sf)
+		сам.сеть, err = marketnet.NewMarketNet(сам)
 		if err != nil {
 			return nil, fmt.Errorf("NewMarket(): in create NetMarket, err=\n\t%w", err)
 		}
 	}
-	return sf, nil
+	return сам, nil
 }
 
 // Пуск -- запускает всю работу рынка в отдельном потоке
@@ -72,24 +72,24 @@ func (сам *Рынок) пуск() {
 // Проверяет  время ожидания рынка
 func (сам *Рынок) проверОжидание() {
 	var (
-		strOut string
-		isFind bool
+		strOut  string
+		iсамind bool
 	)
-	// countDown := sf.CountDown().Get()
+	// countDown := сам.CountDown().Get()
 	фнЕслиСеребро := func() bool { // Найти счётчик цены серебра
 		if ош := сам.сеть.Обновить(); ош != nil { // Принудительное ПЕРВОЕ обновление рынка
 			log.Printf("Market.checkTime(): при обновлении lstMarket, err=\n\t%v\n", ош)
 			return false
 		}
-		isFind := false
+		iсамind := false
 		lstMarket := сам.СписПолучить()
 		for _, strOut = range lstMarket {
 			if strings.Contains(strOut, `alt="Серебро" title="Серебро"> `) {
-				isFind = true
+				iсамind = true
 				break
 			}
 		}
-		if isFind {
+		if iсамind {
 			lstSilver := strings.Split(strOut, `<img class="ico vm" src="/images/icons/silver.png?2" alt="Серебро" title="Серебро"> `)
 			strSilver := lstSilver[1]
 			switch strSilver {
@@ -111,11 +111,11 @@ func (сам *Рынок) проверОжидание() {
 		// Найти счётчик времени
 		for _, strOut = range lstMarket {
 			if strings.Contains(strOut, `Минимальная цена через `) {
-				isFind = true
+				iсамind = true
 				break
 			}
 		}
-		if !isFind {
+		if !iсамind {
 			return // Минимальная цена
 		}
 		lstTime := strings.Split(strOut, `Минимальная цена через `)
@@ -135,18 +135,18 @@ func (сам *Рынок) проверОжидание() {
 func (сам *Рынок) купитьЗолото() bool {
 	var (
 		ind       int
-		isFind    bool
+		iсамind   bool
 		strOut    string
 		lstMarket = сам.СписПолучить()
 		strSilver string
 	)
 	for ind, strOut = range lstMarket {
 		if strings.Contains(strOut, `alt="Серебро" title="Серебро"> `) {
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind { // Не найдена продажа золота за серебро
+	if !iсамind { // Не найдена продажа золота за серебро
 		return false
 	}
 	lstSilver := strings.Split(strOut, `<img class="ico vm" src="/images/icons/silver.png?2" alt="Серебро" title="Серебро"> `)

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

@@ -23,9 +23,9 @@ func NewMarketNet(market types.ИРынок) (*MarketNet, error) {
 		return nil, fmt.Errorf("NewMarketNet(): in create *SectionNet, err=\n\t%w", err)
 	}
 
-	sf := &MarketNet{
+	сам := &MarketNet{
 		СценаСеть: sectionNet,
 	}
 
-	return sf, nil
+	return сам, nil
 }

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

@@ -124,10 +124,10 @@ func (сам *Шахта) пуск() {
 // Проверяет количество продукта в шахте
 func (сам *Шахта) количествоПолучить() {
 	var (
-		ind    int
-		strOut string
-		isFind bool
-		режим  string
+		ind     int
+		strOut  string
+		iсамind bool
+		режим   string
 	)
 	lstMine, err := сам.сеть.Клиент().Get("https://wartank.ru/buildings")
 	if err != nil {
@@ -145,12 +145,12 @@ func (сам *Шахта) количествоПолучить() {
 		// Руда
 		if strings.Contains(strOut, `src="/images/icons/ore.png?2" alt="ore"`) {
 			// <td class="vam"><div class="nwr pr5 gray1"><img class="rico vm" src="/images/icons/ore.png?2" alt="ore"/>&nbsp;1</div></td>
-			isFind = true
+			iсамind = true
 			режим = "руда"
 			break
 		}
 	}
-	if !isFind {
+	if !iсамind {
 		return
 	}
 	switch режим {
@@ -180,8 +180,8 @@ func (сам *Шахта) количествоПолучить() {
 // Проверяет на забор из шахты
 func (сам *Шахта) шахтаЗабрать() {
 	var (
-		strOut string
-		isFind bool
+		strOut  string
+		iсамind bool
 	)
 	списШахта, ош := сам.сеть.Клиент().Get("https://wartank.ru/buildings")
 	if ош != nil {
@@ -191,11 +191,11 @@ func (сам *Шахта) шахтаЗабрать() {
 	// <a class="simple-but border" href="buildings?35-1.ILinkListener-buildings-0-building-rootBlock-actionPanel-takeProductionLink"><span><span>Забрать</span></span></a>
 	for _, strOut = range списШахта {
 		if strings.Contains(strOut, `.ILinkListener-buildings-0-building-rootBlock-actionPanel-takeProductionLink`) {
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind {
+	if !iсамind {
 		return
 	}
 	_ссылка := strings.TrimPrefix(strOut, `<a class="simple-but border" href="`)
@@ -353,8 +353,8 @@ func (сам *Шахта) Сделать() {
 }
 
 // Свинец -- возвращает объект свинца
-func (sf *Шахта) Свинец() types.ИСтатПарам {
-	return sf.свинец
+func (сам *Шахта) Свинец() types.ИСтатПарам {
+	return сам.свинец
 }
 
 // Сталь -- возвращает объект стали
@@ -462,18 +462,18 @@ func (сам *Шахта) рудаСделать() {
 		strTime string
 		strLink string
 		strNum  string
-		isFind  bool
+		iсамind bool
 	)
 	for ind, strOut = range lstMine {
 		if strings.Contains(strOut, `<span class="green2">Руда</span><br/>`) {
 			strNum = lstMine[ind+1]
 			strTime = lstMine[ind+3]
 			strLink = lstMine[ind+10]
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind {
+	if !iсамind {
 		return
 	}
 	if !strings.Contains(strLink, `>Начать производство<`) {
@@ -489,7 +489,7 @@ func (сам *Шахта) рудаСделать() {
 		// log._rintf("ERRO Шахта.сделатьРуду(): при GET-команде 'начать производство руды', err=\n\t%v\n", err)
 		return
 	}
-	isFind = false
+	iсамind = false
 	for _, strOut = range lstMine {
 		if strings.Contains(strOut, `<title>База</title>`) {
 			// log._rintf("WARN Шахта.сделатьРуду(): при обновлении lstMine обнаружено lstBase\n")
@@ -524,18 +524,18 @@ func (сам *Шахта) железоСделать() {
 		strTime string
 		strLink string
 		strNum  string
-		isFind  bool
+		iсамind bool
 	)
 	for ind, strOut = range lstMine {
 		if strings.Contains(strOut, `<span class="green2">Железо</span><br/>`) {
 			strNum = lstMine[ind+1]
 			strTime = lstMine[ind+3]
 			strLink = lstMine[ind+10]
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind {
+	if !iсамind {
 		return
 	}
 	if !strings.Contains(strLink, `>Начать производство<`) {
@@ -584,18 +584,18 @@ func (сам *Шахта) стальСделать() {
 		strTime string
 		strLink string
 		strNum  string
-		isFind  bool
+		iсамind bool
 	)
 	for ind, strOut = range lstMine {
 		if strings.Contains(strOut, `<span class="green2">Сталь</span><br/>`) {
 			strNum = lstMine[ind+1]
 			strTime = lstMine[ind+3]
 			strLink = lstMine[ind+10]
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind {
+	if !iсамind {
 		return
 	}
 	if !strings.Contains(strLink, `>Начать производство<`) {
@@ -644,18 +644,18 @@ func (сам *Шахта) свинецСделать() {
 		strTime string
 		strLink string
 		strNum  string
-		isFind  bool
+		iсамind bool
 	)
 	for ind, strOut = range lstMine {
 		if strings.Contains(strOut, `<span class="green2">Свинец</span><br/>`) {
 			strNum = lstMine[ind+1]
 			strTime = lstMine[ind+3]
 			strLink = lstMine[ind+10]
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind {
+	if !iсамind {
 		return
 	}
 	if !strings.Contains(strLink, `>Начать производство<`) {

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

@@ -21,8 +21,8 @@ func NewMineNet(mine types.ИБазаШахта) (*MineNet, error) {
 	if err != nil {
 		return nil, fmt.Errorf("NewMineNet(): in create *SectionNet, err=\n\t%w", err)
 	}
-	sf := &MineNet{
+	сам := &MineNet{
 		СценаСеть: sectionNet,
 	}
-	return sf, nil
+	return сам, nil
 }

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

@@ -87,8 +87,8 @@ func (сам *Полигон) ПродуктВремяСейчас() string {
 }
 
 // Пуск -- запускает работу полигона в отдельном потоке
-func (sf *Полигон) Пуск() error {
-	go sf.пуск()
+func (сам *Полигон) Пуск() error {
+	go сам.пуск()
 	return nil
 }
 
@@ -124,8 +124,8 @@ func (сам *Полигон) пуск() {
 // Проверяет на ускорение апгрейда полигона
 func (сам *Полигон) проверитьУскорение() {
 	var (
-		strOut = ""
-		isFind bool
+		strOut  = ""
+		iсамind bool
 	)
 	lstBase, err := сам.сеть.Клиент().Get("https://wartank.ru/buildings")
 	if err != nil {
@@ -146,15 +146,15 @@ func (сам *Полигон) проверитьУскорение() {
 		}
 	}
 	{ // Проверка на бесплатное ускорение апгрейда
-		isFind = false
+		iсамind = false
 		for _, strOut = range lstBase {
 			if strings.Contains(strOut, `Производит снаряды, ремкомплекты<br/>`) {
 				// Убедиться что есть строка платного ускорения
-				isFind = true
+				iсамind = true
 				break
 			}
 		}
-		if !isFind {
+		if !iсамind {
 			return
 		}
 		if !strings.Contains(strOut, `>Ускорение<`) {
@@ -258,7 +258,7 @@ func (сам *Полигон) построитьПровер() {
 func (сам *Полигон) времяОбнов() {
 	var (
 		strLastTime string
-		isFind      bool
+		iсамind     bool
 		isSet       bool
 		lstPolygon  = сам.СписПолучить()
 	)
@@ -270,11 +270,11 @@ func (сам *Полигон) времяОбнов() {
 	for _, lastTime := range lstPolygon {
 		if strings.Contains(lastTime, `>Осталось: `) {
 			strLastTime = lastTime
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind { // Время полигона вышло
+	if !iсамind { // Время полигона вышло
 		return
 	}
 	lstTime := strings.Split(strLastTime, `>Осталось: `)
@@ -291,7 +291,7 @@ func (сам *Полигон) времяОбнов() {
 // Проверяет что именно активировано
 func (сам *Полигон) усилениеПровер() {
 	var (
-		isFind     bool
+		iсамind    bool
 		lstPolygon = сам.СписПолучить()
 		ind        = 0
 		strOut     string
@@ -300,11 +300,11 @@ func (сам *Полигон) усилениеПровер() {
 	for ind, strOut = range lstPolygon {
 		if strings.Contains(strOut, `<span>Активно</span>`) {
 			ind -= 9
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind {
+	if !iсамind {
 		return
 	}
 	strOut = lstPolygon[ind]
@@ -338,7 +338,7 @@ func (сам *Полигон) усилениеПровер() {
 // Выбирает самый слабый параметр и усиливает его
 func (сам *Полигон) усилениеДобавить() {
 	if ош := сам.сеть.Обновить(); ош != nil {
-		// log._rintf("Polygon.checkPolygon(): при принудительном обновлении lstPlygon, mode=%s\terr=\n\t%v\n", sf.ModeCurrent().Get(), err)
+		// log._rintf("Polygon.checkPolygon(): при принудительном обновлении lstPlygon, mode=%s\terr=\n\t%v\n", сам.ModeCurrent().Get(), err)
 		сам.ОбратВремяУст("05")
 		return
 	}
@@ -380,19 +380,19 @@ func (сам *Полигон) усилениеДобавить() {
 
 	// Найти нужную строку активации
 	var (
-		ind    int
-		strOut string
-		isFind bool
+		ind     int
+		strOut  string
+		iсамind bool
 	)
 	switch strParam {
 	case стрАтака: // Усиливаем атаку
 		for ind, strOut = range lstPoligon {
 			if strings.Contains(strOut, `>усиление атаки<`) {
-				isFind = true
+				iсамind = true
 				break
 			}
 		}
-		if !isFind {
+		if !iсамind {
 			return
 		}
 		ind += 8
@@ -423,14 +423,14 @@ func (сам *Полигон) усилениеДобавить() {
 			сам.СценаРежим().РаботаУст(стрАтака)
 		}
 	case стрБроня: // Усиливаем броню
-		isFind = false
+		iсамind = false
 		for ind, strOut = range lstPoligon {
 			if strings.Contains(strOut, `>усиление брони<`) {
-				isFind = true
+				iсамind = true
 				break
 			}
 		}
-		if !isFind {
+		if !iсамind {
 			return
 		}
 		ind += 8
@@ -461,14 +461,14 @@ func (сам *Полигон) усилениеДобавить() {
 			сам.СценаРежим().РаботаУст(стрБроня)
 		}
 	case стрТочность: // Усиливаем точность
-		isFind = false
+		iсамind = false
 		for ind, strOut = range lstPoligon {
 			if strings.Contains(strOut, `>улучшение точности<`) {
-				isFind = true
+				iсамind = true
 				break
 			}
 		}
-		if !isFind {
+		if !iсамind {
 			return
 		}
 		ind += 8
@@ -499,14 +499,14 @@ func (сам *Полигон) усилениеДобавить() {
 			сам.СценаРежим().РаботаУст(стрТочность)
 		}
 	case стрПрочность: // Усиливаем мощность
-		isFind = false
+		iсамind = false
 		for ind, strOut = range lstPoligon {
 			if strings.Contains(strOut, `>увеличение прочности<`) {
-				isFind = true
+				iсамind = true
 				break
 			}
 		}
-		if !isFind {
+		if !iсамind {
 			return
 		}
 		ind += 8

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

@@ -23,9 +23,9 @@ func НовПолигонСеть(polygon types.ИБазаПолигон) (*По
 		return nil, fmt.Errorf("NewPolygonNet(): in create *SectionNet, err=\n\t%w", err)
 	}
 
-	sf := &ПолигонСеть{
+	сам := &ПолигонСеть{
 		СценаСеть: sectionNet,
 	}
 
-	return sf, nil
+	return сам, nil
 }

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

@@ -51,31 +51,31 @@ func НовСражение(бот types.ИБот) (*Сражение, error) {
 			return nil, fmt.Errorf("НовСражение(): при создании исполнителя сражения, err=\n\t%w", ош)
 		}
 	}
-	// sf.shotTimeFull.Set(8000) // 8000 msec
+	// сам.shotTimeFull.Set(8000) // 8000 msec
 	return сам, nil
 }
 
-func (sf *Сражение) Пуск() error {
-	go sf.пуск()
+func (сам *Сражение) Пуск() error {
+	go сам.пуск()
 	return nil
 }
 
 // запускает в работу сражение
-func (sf *Сражение) пуск() {
+func (сам *Сражение) пуск() {
 	for {
 		select {
-		case <-sf.бот.Кнт().Done():
+		case <-сам.бот.Кнт().Done():
 			return
 		default:
-			sf.регистрация.Зарегистрироваться()
-			sf.ожидание.Ожидать()
-			sf.действие.Танковать()
+			сам.регистрация.Зарегистрироваться()
+			сам.ожидание.Ожидать()
+			сам.действие.Танковать()
 			time.Sleep(time.Second * 2) // Пауза между циклами, чтобы сервер не долбить запросами
 		}
 	}
 }
 
 // ЕслиНачало -- возвращает признак начала сражения (для браузера)
-func (sf *Сражение) ЕслиНачало() types.ИСтатПарам {
-	return sf.действие.Тревога()
+func (сам *Сражение) ЕслиНачало() types.ИСтатПарам {
+	return сам.действие.Тревога()
 }

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

@@ -84,11 +84,11 @@ func (сам *СражениеОжидание) ждать() string {
 	var (
 		strOut    string
 		lstBattle = сам.СписПолучить()
-		isFind    bool
+		iсамind   bool
 	)
 	for _, strOut = range lstBattle {
 		if strings.Contains(strOut, `<span>до начала `) {
-			isFind = true
+			iсамind = true
 			break
 		}
 		// if strings.Contains(strOut, `>ОБЫЧНЫЕ<`) { // Это уже битва
@@ -98,7 +98,7 @@ func (сам *СражениеОжидание) ждать() string {
 		// 	return
 		// }
 	}
-	if !isFind { // Сражение уже идёт
+	if !iсамind { // Сражение уже идёт
 		return ""
 	}
 	// Найдена строка ожидания начала сражения

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

@@ -37,17 +37,17 @@ func НовСражениеИсполнитель(bot types.ИБот) (*Сраж
 	if ош != nil {
 		return nil, fmt.Errorf("NewBattleWorker(): при создании стат еслиНачало, err=\n\t%w", ош)
 	}
-	sf := &СражениеИсполнитель{
+	сам := &СражениеИсполнитель{
 		Секция:     section,
 		бот:        bot,
 		еслиНачало: еслиНачало,
 		sound:      battlesound.NewBattleSound(),
 	}
-	sf.сеть, err = scene_net.НовСекцияСеть(sf, "https://wartank.ru/pve")
+	сам.сеть, err = scene_net.НовСекцияСеть(сам, "https://wartank.ru/pve")
 	if err != nil {
 		return nil, fmt.Errorf("NewBattleWorker(): in create *SectionNet, err=\n\t%w", err)
 	}
-	return sf, nil
+	return сам, nil
 }
 
 // Танковать -- выполняет битву
@@ -64,6 +64,6 @@ func (сам *СражениеИсполнитель) Танковать() {
 }
 
 // Тревога -- возвращает признак начала сражения (для браузера)
-func (sf *СражениеИсполнитель) Тревога() types.ИСтатПарам {
-	return sf.еслиНачало
+func (сам *СражениеИсполнитель) Тревога() types.ИСтатПарам {
+	return сам.еслиНачало
 }

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

@@ -88,28 +88,28 @@ func (сам *СражениеДействие) пуск() {
 }
 
 // Сеть -- возвращает сетевой компонент секции
-func (sf *СражениеДействие) Сеть() types.ИСценаСеть {
-	return sf.сеть
+func (сам *СражениеДействие) Сеть() types.ИСценаСеть {
+	return сам.сеть
 }
 
-func (sf *СражениеДействие) МанёврНадоУст() {
-	if sf.манёвр == nil {
+func (сам *СражениеДействие) МанёврНадоУст() {
+	if сам.манёвр == nil {
 		return
 	}
-	sf.манёвр.УстНадо()
+	сам.манёвр.УстНадо()
 }
 
 // ВыстрелБлок -- признак запрета стрельбы при слабом здоровье
-func (sf *СражениеДействие) ВыстрелБлок() *isshot.IsShot {
-	return sf.еслиВыстрел
+func (сам *СражениеДействие) ВыстрелБлок() *isshot.IsShot {
+	return сам.еслиВыстрел
 }
 
 // Кнт -- возвращает контекст отмены сражения
-func (sf *СражениеДействие) Кнт() context.Context {
-	return sf.кнт
+func (сам *СражениеДействие) Кнт() context.Context {
+	return сам.кнт
 }
 
 // ОтменитьДействие -- вызов функции отмены контекста сражения
-func (sf *СражениеДействие) Отменить() {
-	sf.фнОтменить()
+func (сам *СражениеДействие) Отменить() {
+	сам.фнОтменить()
 }

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

@@ -24,16 +24,16 @@ func NewBattleSound() *BattleSound {
 }
 
 // Play -- играет музончик, если можно
-func (sf *BattleSound) Play() {
-	if sf.isPlay.Get() {
+func (сам *BattleSound) Play() {
+	if сам.isPlay.Get() {
 		return
 	}
-	go sf.play()
+	go сам.play()
 }
 
 // Проигрывает экслюзивно в отдельном потоке звук
-func (sf *BattleSound) play() {
-	sf.isPlay.Set()
+func (сам *BattleSound) play() {
+	сам.isPlay.Set()
 	val := 7
 	for val > 0 {
 		sound.Battle()
@@ -45,5 +45,5 @@ func (sf *BattleSound) play() {
 		val--
 		time.Sleep(time.Second * 1)
 	}
-	sf.isPlay.Reset()
+	сам.isPlay.Reset()
 }

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

@@ -20,22 +20,22 @@ func NewIsPlay() *IsPlay {
 }
 
 // Get -- возвращает хранимое состояние
-func (sf *IsPlay) Get() bool {
-	sf.block.RLock()
-	defer sf.block.RUnlock()
-	return sf.val
+func (сам *IsPlay) Get() bool {
+	сам.block.RLock()
+	defer сам.block.RUnlock()
+	return сам.val
 }
 
 // Set -- устанавливает хранимое состояние
-func (sf *IsPlay) Set() {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	sf.val = true
+func (сам *IsPlay) Set() {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	сам.val = true
 }
 
 // Reset -- сбрасывает хранимое состояние
-func (sf *IsPlay) Reset() {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	sf.val = false
+func (сам *IsPlay) Reset() {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	сам.val = false
 }

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

@@ -26,13 +26,13 @@ func НовЗдоровье(действие types.ИСражениеДейст
 			return nil, fmt.Errorf("НовЗдоровье(): действие==nil")
 		}
 	}
-	sf := &Здоровье{
+	сам := &Здоровье{
 		ИСражениеДействие: действие,
 		канТик:            make(chan int, 2),
 	}
-	go sf.makeTik()
-	go sf.пуск()
-	return sf, nil
+	go сам.makeTik()
+	go сам.пуск()
+	return сам, nil
 }
 
 // Отправляе ттики с заданным равным интервалом

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

@@ -20,27 +20,27 @@ func NewHealthTime() *HealthTime {
 }
 
 // Get -- возвращает хранимое временное здоровье
-func (sf *HealthTime) Get() int {
-	sf.block.RLock()
-	defer sf.block.RUnlock()
-	return sf.val
+func (сам *HealthTime) Get() int {
+	сам.block.RLock()
+	defer сам.block.RUnlock()
+	return сам.val
 }
 
 // IsZero -- возвращает истину, если значение обнулено
-func (sf *HealthTime) IsZero() bool {
-	sf.block.RLock()
-	defer sf.block.RUnlock()
-	return sf.val == 0
+func (сам *HealthTime) IsZero() bool {
+	сам.block.RLock()
+	defer сам.block.RUnlock()
+	return сам.val == 0
 }
 
 // Set -- устанавливает значение по требованию
-func (sf *HealthTime) Set(val int) {
-	sf.block.Lock()
-	defer sf.block.Unlock()
+func (сам *HealthTime) Set(val int) {
+	сам.block.Lock()
+	defer сам.block.Unlock()
 	if val < 0 {
 		// log._rintf("WARN HealthTime.Set(): отрицательное значение(%v)\n", val)
-		sf.val = 0
+		сам.val = 0
 		return
 	}
-	sf.val = val
+	сам.val = val
 }

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

@@ -20,22 +20,22 @@ func NewIsRepair() *IsRepair {
 }
 
 // Get -- возвращает хранимое состояние
-func (sf *IsRepair) Get() bool {
-	sf.block.RLock()
-	defer sf.block.RUnlock()
-	return sf.val
+func (сам *IsRepair) Get() bool {
+	сам.block.RLock()
+	defer сам.block.RUnlock()
+	return сам.val
 }
 
 // Set -- устанавливает хранимое состояние
-func (sf *IsRepair) Set() {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	sf.val = true
+func (сам *IsRepair) Set() {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	сам.val = true
 }
 
 // Reset -- сбрасывает хранимое состояние
-func (sf *IsRepair) Reset() {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	sf.val = false
+func (сам *IsRepair) Reset() {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	сам.val = false
 }

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

@@ -23,23 +23,23 @@ func NewRepairTime() *RepairTime {
 }
 
 // Получ -- возвращает хранимое значение времени
-func (sf *RepairTime) Получ() int {
-	sf.block.RLock()
-	defer sf.block.RUnlock()
-	return sf.val
+func (сам *RepairTime) Получ() int {
+	сам.block.RLock()
+	defer сам.block.RUnlock()
+	return сам.val
 }
 
 // GetOld -- возвращает хранимое старое значение времени
-func (sf *RepairTime) GetOld() int {
-	sf.block.RLock()
-	defer sf.block.RUnlock()
-	return sf.valOld
+func (сам *RepairTime) GetOld() int {
+	сам.block.RLock()
+	defer сам.block.RUnlock()
+	return сам.valOld
 }
 
 // Set -- устанавливает хранимое время восстановления ремки
-func (sf *RepairTime) Set(val string) error {
-	sf.block.Lock()
-	defer sf.block.Unlock()
+func (сам *RepairTime) Set(val string) error {
+	сам.block.Lock()
+	defer сам.block.Unlock()
 	iVal, err := strconv.Atoi(val)
 	if err != nil {
 		return fmt.Errorf("RepairTime.Set(): val(%v) не число, err=%w", val, err)
@@ -47,31 +47,31 @@ func (sf *RepairTime) Set(val string) error {
 	if iVal < 0 {
 		return fmt.Errorf("RepairTime.Set(): val(%v) < 0", iVal)
 	}
-	sf.valOld = sf.val
-	sf.val = iVal
+	сам.valOld = сам.val
+	сам.val = iVal
 	return nil
 }
 
 // Dec -- уменьшает на секунду время восстановления
-func (sf *RepairTime) Dec() {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	if sf.val > 0 {
-		sf.valOld = sf.val
-		sf.val--
+func (сам *RepairTime) Dec() {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	if сам.val > 0 {
+		сам.valOld = сам.val
+		сам.val--
 	}
 }
 
 // ЕслиГотово -- возвращает признак готовности восстановления
-func (sf *RepairTime) ЕслиМожно() bool {
-	sf.block.RLock()
-	defer sf.block.RUnlock()
-	return sf.val == 0
+func (сам *RepairTime) ЕслиМожно() bool {
+	сам.block.RLock()
+	defer сам.block.RUnlock()
+	return сам.val == 0
 }
 
 // ЕслиИзменилось -- возвращает признак изменения здоровья после присвоения
-func (sf *RepairTime) ЕслиИзменилось() bool {
-	sf.block.RLock()
-	defer sf.block.RUnlock()
-	return sf.val == sf.valOld
+func (сам *RepairTime) ЕслиИзменилось() bool {
+	сам.block.RLock()
+	defer сам.block.RUnlock()
+	return сам.val == сам.valOld
 }

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

@@ -22,22 +22,22 @@ func NewIsManevr() *IsManevr {
 }
 
 // Get -- возвращает хранимое состояние
-func (sf *IsManevr) Get() bool {
-	sf.block.RLock()
-	defer sf.block.RUnlock()
-	return sf.val
+func (сам *IsManevr) Get() bool {
+	сам.block.RLock()
+	defer сам.block.RUnlock()
+	return сам.val
 }
 
 // Set -- устанавливает хранимое состояние
-func (sf *IsManevr) Set() {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	sf.val = true
+func (сам *IsManevr) Set() {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	сам.val = true
 }
 
 // Сброс -- сбрасывает хранимое состояние
-func (sf *IsManevr) Сброс() {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	sf.val = false
+func (сам *IsManevr) Сброс() {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	сам.val = false
 }

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

@@ -34,33 +34,33 @@ func НовМанёвр(действие types.ИСражениеДействи
 			return nil, fmt.Errorf("НовМанёвр(): действие==nil")
 		}
 	}
-	sf := &Манёвр{
+	сам := &Манёвр{
 		ИСражениеДействие: действие,
 		еслиМанёврНадо:    ismanevr.NewIsManevr(),
 		времяЖдать:        repairtime.NewRepairTime(),
 		chTick:            make(chan int, 1),
 	}
-	_ = sf.времяЖдать.Set("0") // При запуске боя есть возможность маневрировать
-	go sf.makeTick()
-	go sf.пуск()
-	return sf, nil
+	_ = сам.времяЖдать.Set("0") // При запуске боя есть возможность маневрировать
+	go сам.makeTick()
+	go сам.пуск()
+	return сам, nil
 }
 
 // Генерирует тик для уменьшения времени ожидания восстановления возможности манёвра
-func (sf *Манёвр) makeTick() {
+func (сам *Манёвр) makeTick() {
 	defer func() {
-		close(sf.chTick)
+		close(сам.chTick)
 		// log._rintf("Manevr.makeTick(): сражение завершено\n")
 	}()
 	for {
 		select {
-		case <-sf.Кнт().Done():
+		case <-сам.Кнт().Done():
 			return
 		default:
-			if sf.времяЖдать.Получ() <= 0 {
-				sf.chTick <- 1
+			if сам.времяЖдать.Получ() <= 0 {
+				сам.chTick <- 1
 			}
-			sf.времяЖдать.Dec()
+			сам.времяЖдать.Dec()
 			time.Sleep(time.Second * 1)
 		}
 	}
@@ -80,7 +80,7 @@ func (сам *Манёвр) пуск() {
 // Ищет время для манёвра
 func (сам *Манёвр) времяМанёврНайти() {
 	var (
-		isFind      bool
+		iсамind     bool
 		ind         int
 		lstBattleOn = сам.СписПолучить()
 		strOut      string
@@ -88,11 +88,11 @@ func (сам *Манёвр) времяМанёврНайти() {
 	for ind, strOut = range lstBattleOn {
 		// <a href="pve?4-88.ILinkListener-currentControl-maneuverLink" class="simple-but blue"><span><span>5 секунд</span></span></a>
 		if strings.Contains(strOut, `-currentControl-maneuverLink`) {
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind { // Или манёвр успел восстановиться, или конец сражения
+	if !iсамind { // Или манёвр успел восстановиться, или конец сражения
 		if strings.Contains(strOut, `<span>Маневр</span>`) {
 			_ = сам.времяЖдать.Set("0")
 			return
@@ -127,18 +127,18 @@ func (сам *Манёвр) времяМанёврНайти() {
 // Манёвр по возможности
 func (сам *Манёвр) манёвр() {
 	var (
-		isFind      = false
+		iсамind     = false
 		lstBattleOn = сам.СписПолучить()
 		strOut      = ""
 	)
 	for _, strOut = range lstBattleOn {
 		// <a href="pve?4-21.ILinkListener-currentControl-maneuverLink" class="simple-but blue"><span><span>Маневр</span></span></a>
 		if strings.Contains(strOut, `<span>Маневр</span>`) {
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind { // Либо ждём восстановления манёвра, либо сражение закончилось
+	if !iсамind { // Либо ждём восстановления манёвра, либо сражение закончилось
 		return
 	}
 	{ // Попытка манёвра
@@ -163,11 +163,11 @@ func (сам *Манёвр) манёвр() {
 }
 
 // ЕслиГотов -- возвращает готовность манёвра
-func (sf *Манёвр) ЕслиГотов() bool {
-	return sf.времяЖдать.ЕслиМожно()
+func (сам *Манёвр) ЕслиГотов() bool {
+	return сам.времяЖдать.ЕслиМожно()
 }
 
 // УстНадо -- устанавливает признак необходимости манёвра
-func (sf *Манёвр) УстНадо() {
-	sf.еслиМанёврНадо.Set()
+func (сам *Манёвр) УстНадо() {
+	сам.еслиМанёврНадо.Set()
 }

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

@@ -27,27 +27,27 @@ func NewDamage() *Damage {
 }
 
 // Set -- устанавливает урон
-func (sf *Damage) Set(val alias.Урон) {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	if sf.val == 0 { // Первоначальное присвоение
-		sf.val = val
+func (сам *Damage) Set(val alias.Урон) {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	if сам.val == 0 { // Первоначальное присвоение
+		сам.val = val
 		return
 	}
 	switch {
-	case sf.val > val: // Урон уменьшился
-		sf.res = "down"
-	case sf.val < val: // Урон увеличился
-		sf.res = "up"
+	case сам.val > val: // Урон уменьшился
+		сам.res = "down"
+	case сам.val < val: // Урон увеличился
+		сам.res = "up"
 	default: // Урон не изменился
-		sf.res = "none"
+		сам.res = "none"
 	}
-	sf.val = val
+	сам.val = val
 }
 
 // Result -- возвращает результат сравнения урона старого и текущего
-func (sf *Damage) Result() string {
-	sf.block.RLock()
-	defer sf.block.RUnlock()
-	return sf.res
+func (сам *Damage) Result() string {
+	сам.block.RLock()
+	defer сам.block.RUnlock()
+	return сам.res
 }

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

@@ -20,22 +20,22 @@ func NewIsShot() *IsShot {
 }
 
 // Get -- возвращает хранимое состояние
-func (sf *IsShot) Get() bool {
-	sf.block.RLock()
-	defer sf.block.RUnlock()
-	return sf.val
+func (сам *IsShot) Get() bool {
+	сам.block.RLock()
+	defer сам.block.RUnlock()
+	return сам.val
 }
 
 // Set -- устанавливает хранимое состояние
-func (sf *IsShot) Set() {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	sf.val = true
+func (сам *IsShot) Set() {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	сам.val = true
 }
 
 // Reset -- сбрасывает хранимое состояние
-func (sf *IsShot) Reset() {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	sf.val = false
+func (сам *IsShot) Reset() {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	сам.val = false
 }

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

@@ -32,14 +32,14 @@ func НовВыстрел(действие types.ИСражениеДейств
 			return nil, fmt.Errorf("НовВыстрел(): действие==nil")
 		}
 	}
-	sf := &Выстрел{
+	сам := &Выстрел{
 		ИСражениеДействие: действие,
 		выстрелСчёт:       1,
 		канТик:            make(chan int, 2),
 	}
-	go sf.делайТик()
-	go sf.пуск()
-	return sf, nil
+	go сам.делайТик()
+	go сам.пуск()
+	return сам, nil
 }
 
 // Генерирует тики, когда можно стрелять

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

@@ -24,53 +24,53 @@ func NewShotTime() *ShotTime {
 }
 
 // Get -- возвращает хранимое время до выстрела
-func (sf *ShotTime) Get() alias.МилСек {
-	sf.block.RLock()
-	defer sf.block.RUnlock()
-	return sf.val
+func (сам *ShotTime) Get() alias.МилСек {
+	сам.block.RLock()
+	defer сам.block.RUnlock()
+	return сам.val
 }
 
 // Dec5 -- уменьшает время до выстрела на 5 мсек
-func (sf *ShotTime) Dec5() {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	sf.val -= 5
-	if sf.val < 0 {
-		sf.val = 0
+func (сам *ShotTime) Dec5() {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	сам.val -= 5
+	if сам.val < 0 {
+		сам.val = 0
 	}
 }
 
 // Dec30 -- уменьшает время до выстрела на 30 мсек
-func (sf *ShotTime) Dec30() {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	sf.val -= 30
-	if sf.val < 0 {
-		sf.val = 0
+func (сам *ShotTime) Dec30() {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	сам.val -= 30
+	if сам.val < 0 {
+		сам.val = 0
 	}
 }
 
 // Inc210 -- увеличивает время до выстрела на 210 мсек
-func (sf *ShotTime) Inc210() {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	sf.val += 210
+func (сам *ShotTime) Inc210() {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	сам.val += 210
 }
 
 // IsZero -- возвращает истину, если значение обнулено
-func (sf *ShotTime) IsZero() bool {
-	sf.block.RLock()
-	defer sf.block.RUnlock()
-	return sf.val == 0
+func (сам *ShotTime) IsZero() bool {
+	сам.block.RLock()
+	defer сам.block.RUnlock()
+	return сам.val == 0
 }
 
 // Set -- устанавливает значение по требованию
-func (sf *ShotTime) Set(val alias.МилСек) {
-	sf.block.Lock()
-	defer sf.block.Unlock()
+func (сам *ShotTime) Set(val alias.МилСек) {
+	сам.block.Lock()
+	defer сам.block.Unlock()
 	if val < 0 {
 		logrus.WithField("val", val).Error("ShotTime.Set(): отрицательное значение")
 		return
 	}
-	sf.val = val
+	сам.val = val
 }

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

@@ -21,8 +21,8 @@ func NewBattleNet(battle types.ИСражениеСцена) (*BattleNet, error)
 	if err != nil {
 		return nil, fmt.Errorf("NewBattleNet(): in create *SectionNet, err=\n\t%w", err)
 	}
-	sf := &BattleNet{
+	сам := &BattleNet{
 		СценаСеть: sectionNet,
 	}
-	return sf, nil
+	return сам, nil
 }

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

@@ -15,19 +15,19 @@ func NewIsRun() *IsRun {
 	return &IsRun{}
 }
 
-func (sf *IsRun) Get() bool {
-	sf.block.RLock()
-	defer sf.block.RUnlock()
-	return sf.val
+func (сам *IsRun) Get() bool {
+	сам.block.RLock()
+	defer сам.block.RUnlock()
+	return сам.val
 }
-func (sf *IsRun) Set() {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	sf.val = true
+func (сам *IsRun) Set() {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	сам.val = true
 }
 
-func (sf *IsRun) Reset() {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	sf.val = false
+func (сам *IsRun) Reset() {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	сам.val = false
 }

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

@@ -38,34 +38,34 @@ func НовКонвой(bot types.ИБот) (*Конвой, error) {
 	if ош != nil {
 		return nil, fmt.Errorf("НовКонвой(): при создании статы славы, err=\n\t%w", ош)
 	}
-	sf := &Конвой{
+	сам := &Конвой{
 		Секция: section,
 		бот:    bot,
 		слава:  слава,
 	}
-	sf.net, err = convoynet.NewConvoyNet(sf)
+	сам.net, err = convoynet.NewConvoyNet(сам)
 	if err != nil {
 		return nil, fmt.Errorf("НовКонвой(): in create *SectionNet, err=\n\t%w", err)
 	}
-	return sf, nil
+	return сам, nil
 }
 
 // Пуск -- запускает конвой в работу
-func (sf *Конвой) Пуск() error {
-	go sf.пуск()
+func (сам *Конвой) Пуск() error {
+	go сам.пуск()
 	return nil
 }
 
 // UpdateLst -- принудительно обновляет состояние конвоя
-func (sf *Конвой) UpdateLst() {
-	if err := sf.net.Обновить(); err != nil {
+func (сам *Конвой) UpdateLst() {
+	if err := сам.net.Обновить(); err != nil {
 		log.Printf("Конвой.UpdateLst(): err=\n\t%v\n", err)
 	}
 }
 
 // Слава --возвращает счётчик славы конвоя
-func (sf *Конвой) Слава() types.ИСтатПарам {
-	return sf.слава
+func (сам *Конвой) Слава() types.ИСтатПарам {
+	return сам.слава
 }
 
 // обрабатывает конвой
@@ -107,21 +107,21 @@ func (сам *Конвой) атаковать() {
 }
 
 // Обновляет славу по требованию
-func (sf *Конвой) Обновить() {
+func (сам *Конвой) Обновить() {
 	// Найти строку с упоминанием оставшегося времени конвоя
-	lstConvoy := sf.СписПолучить()
+	lstConvoy := сам.СписПолучить()
 	var (
 		strGlory string
-		isFind   bool
+		iсамind  bool
 	)
 	for _, lastTime := range lstConvoy {
 		if strings.Contains(lastTime, `alt="Слава" title="Слава"> `) {
 			strGlory = lastTime
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind { // Не найдена строка со славой -- это атака
+	if !iсамind { // Не найдена строка со славой -- это атака
 		return
 	}
 	// Ищем количество славы
@@ -132,28 +132,28 @@ func (sf *Конвой) Обновить() {
 		// log._rintf("ERRO ConvoyNet.updateGlory(): слава(%v) не число, err=\n\t%v\n", strGlory, err)
 		return
 	}
-	sf.слава.Уст(iGlory)
+	сам.слава.Уст(iGlory)
 }
 
 // Обновляет оставшееся время конвоя
-func (sf *Конвой) обновитьВремя() {
+func (сам *Конвой) обновитьВремя() {
 	// Время подходит надо обновляться
-	if err := sf.net.Обновить(); err != nil {
+	if err := сам.net.Обновить(); err != nil {
 		logrus.WithError(err).Error("Конвой.обновитьВремя(): при выполнении GET-команды обновления")
-		sf.ОбратВремяУст("20")
+		сам.ОбратВремяУст("20")
 		return
 	}
 	// Найти строку с упоминанием оставшегося времени конвоя
-	lstConvoy := sf.СписПолучить()
+	lstConvoy := сам.СписПолучить()
 	var (
 		strLastTime string
-		isFind      bool
+		iсамind     bool
 		isMask      bool
 	)
 	for _, lastTime := range lstConvoy {
 		if strings.Contains(lastTime, `До следующего конвоя: `) {
 			strLastTime = lastTime
-			isFind = true
+			iсамind = true
 			break
 		}
 		if strings.Contains(lastTime, `Полная маскировка через `) {
@@ -174,29 +174,29 @@ func (sf *Конвой) обновитьВремя() {
 		}
 	}
 	switch {
-	case isFind: // Большая пауза между конвоями
+	case iсамind: // Большая пауза между конвоями
 		// Ждём окончания ожидания конвоя
 		lstTime := strings.Split(strLastTime, `До следующего конвоя: `)
 		strLastTime = lstTime[1]
-		if err := sf.Уст(alias.Время(strLastTime)); err != nil {
+		if err := сам.Уст(alias.Время(strLastTime)); err != nil {
 			// log._rintf("WARN Конвой.обновитьВремя(): при установке времени ожидания конвоя(%v)\n\terr=%v\n", strLastTime, err)
-			sf.ОбратВремяУст("10")
+			сам.ОбратВремяУст("10")
 		}
 	case isMask: // Если маскировка между конвоями
 		// Ждём окончания ожидания конвоя
 		lstTime := strings.Split(strLastTime, `Полная маскировка через `)
 		strLastTime = lstTime[1]
-		if err := sf.Уст(alias.Время(strLastTime)); err != nil {
+		if err := сам.Уст(alias.Время(strLastTime)); err != nil {
 			// log._rintf("ERRO BКонвой.обновитьВремя(): при установке времени банка для 1го режима(%v)\n\terr=%v\n", strLastTime, err)
-			sf.ОбратВремяУст("10")
+			сам.ОбратВремяУст("10")
 		}
 	}
 }
 
 func (сам *Конвой) найтиВбой() string {
 	var (
-		strOut = ""
-		isFind bool
+		strOut  = ""
+		iсамind bool
 	)
 	lstConvoy, err := сам.net.Клиент().Get("https://wartank.ru/convoy")
 	if err != nil {
@@ -213,7 +213,7 @@ func (сам *Конвой) найтиВбой() string {
 			_ссылка := strings.TrimPrefix(strOut, `<div class="bot"><a class="simple-but border" w:id="findEnemy" href="`)
 			_ссылка = strings.TrimSuffix(_ссылка, `"><span><span>Начать разведку</span></span></a></div>`)
 			strOut = "https://wartank.ru/" + _ссылка
-			isFind = true
+			iсамind = true
 			break
 		}
 		если2 := strings.Contains(strOut, `<span>В БОЙ!</span>`)
@@ -225,7 +225,7 @@ func (сам *Конвой) найтиВбой() string {
 			strOut = lstLink[1]
 			lstLink = strings.Split(strOut, `"><span><span>В БОЙ!</span></span></a></div>`)
 			strOut = "https://wartank.ru/" + lstLink[0]
-			isFind = true
+			iсамind = true
 			break
 		}
 		// <div class="bot"><a class="simple-but border" w:id="findEnemy" href="convoy?15-1.ILinkListener-root-findEnemy"><span><span>Начать разведку</span></span></a></div>
@@ -234,7 +234,7 @@ func (сам *Конвой) найтиВбой() string {
 			_ссылка := strings.TrimPrefix(strOut, `<<div class="bot"><a class="simple-but border" w:id="findEnemy" href="`)
 			_ссылка = strings.TrimSuffix(_ссылка, `"><span><span>Начать разведку</span></span></a></div>`)
 			strOut = "https://wartank.ru/" + _ссылка
-			isFind = true
+			iсамind = true
 			break
 		}
 		if strings.Contains(strOut, `>ОБЫЧНЫЕ<`) {
@@ -242,11 +242,11 @@ func (сам *Конвой) найтиВбой() string {
 			strOut = lstLink[1]
 			lstLink = strings.Split(strOut, `" class="simple-but gray"><span><span>ОБЫЧНЫЕ</span></span></a>`)
 			strOut = "https://wartank.ru/" + lstLink[0]
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind { // Время ожидания
+	if !iсамind { // Время ожидания
 		// if err := сам.SetCountDown(1); err != nil {
 		// 	panic(fmt.Errorf("Конвой.атакаНачать(): прb установке CountDown, err=\n\t%w", err))
 		// }
@@ -295,19 +295,19 @@ func (сам *Конвой) атакаНачать() {
 }
 
 // Выполняет атаку на конвой
-func (sf *Конвой) начатьРазведку() {
+func (сам *Конвой) начатьРазведку() {
 	// Вырезать ссылку на атаку
 	strOut := ""
-	isFind := false
-	lstConvoy := sf.СписПолучить()
+	iсамind := false
+	lstConvoy := сам.СписПолучить()
 	// <div class="bot"><a class="simple-but border" w:id="findEnemy" href="convoy?50-1.ILinkListener-root-findEnemy"><span><span>Начать разведку</span></span></a></div>
 	for _, strOut = range lstConvoy {
 		if strings.Contains(strOut, `.ILinkListener-root-findEnemy`) {
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind { // Нечего атаковать
+	if !iсамind { // Нечего атаковать
 		return
 	}
 	// Атакуем конвой
@@ -317,12 +317,12 @@ func (sf *Конвой) начатьРазведку() {
 	link := "https://wartank.ru/" + _link
 	{ // Выполнить атаку
 		var err error
-		lstConvoy, err = sf.net.Клиент().Get(link)
+		lstConvoy, err = сам.net.Клиент().Get(link)
 		if err != nil {
 			log.Printf("Конвой.attack(): in get page find attack, err=\n\t%v\n", err)
 			return
 		}
-		if err = sf.СтрОбновить(lstConvoy); err != nil {
+		if err = сам.СтрОбновить(lstConvoy); err != nil {
 			log.Printf("Конвой.attack(): при обновлении lstConvoy, err=\n\t%v\n", err)
 			return
 		}
@@ -330,24 +330,24 @@ func (sf *Конвой) начатьРазведку() {
 }
 
 // Забирает награду в конвое "Активируй боевую силу"
-func (sf *Конвой) проверитьМиссияРазведкаКонвой() {
+func (сам *Конвой) проверитьМиссияРазведкаКонвой() {
 	var (
-		strOut string
-		isFind bool
+		strOut  string
+		iсамind bool
 	)
-	if err := sf.net.Обновить(); err != nil {
+	if err := сам.net.Обновить(); err != nil {
 		// log._rintf("Конвой.проверитьМиссияРазведкаКонвой(): при обновлении пустого lstConvoy, err=\n\t%v\n", err)
 		return
 	}
-	lstConvoy := sf.СписПолучить()
+	lstConvoy := сам.СписПолучить()
 	// <a class="simple-but border" href="convoy?21-1.ILinkListener-missions-cc-0-c-awardLink"><span><span>Получить награду</span></span></a>
 	for _, strOut = range lstConvoy {
 		if strings.Contains(strOut, `.ILinkListener-missions-cc-0-c-awardLink`) {
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind {
+	if !iсамind {
 		return
 	}
 	// <a class="simple-but border" href="convoy?21-1.ILinkListener-missions-cc-0-c-awardLink"><span><span>Получить награду</span></span></a>
@@ -355,12 +355,12 @@ func (sf *Конвой) проверитьМиссияРазведкаКонво
 	_ссылка = strings.TrimSuffix(_ссылка, `"><span><span>Получить награду</span></span></a>`)
 	// https://wartank.ru/convoy?23-1.ILinkListener-missions-cc-0-c-awardLink
 	ссылка := "https://wartank.ru/" + _ссылка
-	lstConvoy, err := sf.net.Клиент().Get(ссылка)
+	lstConvoy, err := сам.net.Клиент().Get(ссылка)
 	if err != nil {
 		log.Printf("Конвой.проверитьМиссияРазведкаКонвой(): при выполнени команды GET, err=\n\t%v\n", err)
 		return
 	}
-	if err := sf.СтрОбновить(lstConvoy); err != nil {
+	if err := сам.СтрОбновить(lstConvoy); err != nil {
 		log.Printf("Конвой.проверитьМиссияРазведкаКонвой(): пр обновлении lstConvoy, err=\n\t%v\n", err)
 		return
 	}
@@ -368,29 +368,29 @@ func (sf *Конвой) проверитьМиссияРазведкаКонво
 }
 
 // Забирает награду в конвое "Мастер дозора"
-func (sf *Конвой) проверитьМиссияМастерРазведки() {
+func (сам *Конвой) проверитьМиссияМастерРазведки() {
 	var (
 		strOut    string
-		isFind    bool
-		lstConvoy = sf.СписПолучить()
+		iсамind   bool
+		lstConvoy = сам.СписПолучить()
 		ind       int
 	)
 	if len(lstConvoy) == 0 {
-		if err := sf.net.Обновить(); err != nil {
+		if err := сам.net.Обновить(); err != nil {
 			// log._rintf("Конвой.проверитьМиссияМастерРазведки(): при обновлении пустого lstConvoy, err=\n\t%v\n", err)
 			return
 		}
-		lstConvoy = sf.СписПолучить()
+		lstConvoy = сам.СписПолучить()
 	}
 	for ind, strOut = range lstConvoy {
 		if strings.Contains(strOut, `Проведи разведку в конвое<br/>`) {
-			isFind = true
+			iсамind = true
 			ind += 23
 			strOut = lstConvoy[ind]
 			break
 		}
 	}
-	if !isFind {
+	if !iсамind {
 		return
 	}
 	// <a class="simple-but border" href="convoy?61-1.ILinkListener-missions-cc-0-c-awardLink"><span><span>Получить награду</span></span></a>
@@ -402,12 +402,12 @@ func (sf *Конвой) проверитьМиссияМастерРазведк
 	lstLink = strings.Split(strLink, `"><span><span>Получить награду</span></span></a>`)
 	// https://wartank.ru/convoy?61-1.ILinkListener-missions-cc-0-c-awardLink
 	strLink = "https://wartank.ru/" + lstLink[0]
-	lstConvoy, err := sf.net.Get(strLink)
+	lstConvoy, err := сам.net.Get(strLink)
 	if err != nil {
 		// log._rintf("ERRO Конвой.checkMaster(): при выполнени команды GET, err=\n\t%v\n", err)
 		return
 	}
-	if err := sf.СтрОбновить(lstConvoy); err != nil {
+	if err := сам.СтрОбновить(lstConvoy); err != nil {
 		// log._rintf("ERRO Конвой.checkMaster(): пр обновлении lstConvoy, err=\n\t%v\n", err)
 		return
 	}
@@ -415,24 +415,24 @@ func (sf *Конвой) проверитьМиссияМастерРазведк
 }
 
 // Забирает награду в конвое "Уничтожь 6 врагов в конвое"
-func (sf *Конвой) проверитьМиссия6фрагов() {
+func (сам *Конвой) проверитьМиссия6фрагов() {
 	var (
-		strOut string
-		isFind bool
+		strOut  string
+		iсамind bool
 	)
-	if err := sf.net.Обновить(); err != nil {
+	if err := сам.net.Обновить(); err != nil {
 		// log._rintf("Конвой.check6frage(): при обновлении пустого lstConvoy, err=\n\t%v\n", err)
 		return
 	}
-	lstConvoy := sf.СписПолучить()
+	lstConvoy := сам.СписПолучить()
 	// <a class="simple-but border" href="convoy?8-1.ILinkListener-missions-cc-1-c-awardLink"><span><span>Получить награду</span></span></a>
 	for _, strOut = range lstConvoy {
 		if strings.Contains(strOut, `.ILinkListener-missions-cc-1-c-awardLink`) {
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind {
+	if !iсамind {
 		return
 	}
 	// <a class="simple-but border" href="convoy?8-1.ILinkListener-missions-cc-1-c-awardLink"><span><span>Получить награду</span></span></a>
@@ -440,12 +440,12 @@ func (sf *Конвой) проверитьМиссия6фрагов() {
 	_ссылка = strings.TrimSuffix(_ссылка, `"><span><span>Получить награду</span></span></a>`)
 	// https://wartank.ru/convoy?15-1.ILinkListener-missions-cc-1-c-awardLink
 	ссылка := "https://wartank.ru/" + _ссылка
-	lstConvoy, ош := sf.net.Клиент().Get(ссылка)
+	lstConvoy, ош := сам.net.Клиент().Get(ссылка)
 	if ош != nil {
 		log.Printf("Конвой.проверитьМиссия6фрагов(): при выполнени команды GET, err=\n\t%v\n", ош)
 		return
 	}
-	if err := sf.СтрОбновить(lstConvoy); err != nil {
+	if err := сам.СтрОбновить(lstConvoy); err != nil {
 		log.Printf("Конвой.проверитьМиссия6фрагов(): при обновлении lstConvoy, ош=\n\t%v\n", err)
 		return
 	}

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

@@ -21,8 +21,8 @@ func NewConvoyNet(convoy types.Конвой) (*ConvoyNet, error) {
 	if err != nil {
 		return nil, fmt.Errorf("NewConvoyNet(): in create *SectionNet, err=\n\t%w", err)
 	}
-	sf := &ConvoyNet{
+	сам := &ConvoyNet{
 		СценаСеть: sectionNet,
 	}
-	return sf, nil
+	return сам, nil
 }

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

@@ -48,7 +48,7 @@ func NewDivWar(bot types.ИБот) (*DivWar, error) {
 	if ош != nil {
 		return nil, fmt.Errorf("NewDivWar(): при создании стат еслиНач, ош=\n\t%w", ош)
 	}
-	sf := &DivWar{
+	сам := &DivWar{
 		bot:      bot,
 		alarm:    еслиНач,
 		chDivWar: make(chan int, 1),
@@ -56,102 +56,102 @@ func NewDivWar(bot types.ИБот) (*DivWar, error) {
 		conn:     bot.Сеть().Коннект(),
 		login:    "prospero tank",
 	}
-	// sf.shotTimeFull.Set(8000) // 8000 msec
+	// сам.shotTimeFull.Set(8000) // 8000 msec
 	var err error
 	{ // ISection
-		sf.Секция, err = section.НовСекция(bot, "Битва дивизий", `<span>до начала `)
+		сам.Секция, err = section.НовСекция(bot, "Битва дивизий", `<span>до начала `)
 		if err != nil {
 			return nil, fmt.Errorf("NewDivWar(): in create *Section, err=\n\t%w", err)
 		}
 	}
 	{ // Net
-		sf.net, err = divwarnet.NewDivWarNet(bot)
+		сам.net, err = divwarnet.NewDivWarNet(bot)
 		if err != nil {
 			return nil, fmt.Errorf("NewDivWar(): при создании DivWarNet, err=\n\t%w", err)
 		}
 	}
-	go sf.run()
-	go sf.reservTick()
-	return sf, nil
+	go сам.run()
+	go сам.reservTick()
+	return сам, nil
 }
 
-func (sf *DivWar) reservTick() {
+func (сам *DivWar) reservTick() {
 	for {
 		select {
-		case <-sf.bot.Кнт().Done():
+		case <-сам.bot.Кнт().Done():
 			return
 		default:
-			ct0 := sf.ВремяОстат().ПолучМилСек()
+			ct0 := сам.ВремяОстат().ПолучМилСек()
 			time.Sleep(time.Second * 7)
-			ct1 := sf.ВремяОстат().ПолучМилСек()
+			ct1 := сам.ВремяОстат().ПолучМилСек()
 			if ct1.Сек() != ct0.Сек() {
 				continue
 			}
-			if sf.divon != nil {
+			if сам.divon != nil {
 				continue
 			}
-			sf.chDivWar <- 1
+			сам.chDivWar <- 1
 		}
 	}
 }
 
 // запускает в работу битву дивизий
-func (sf *DivWar) run() {
-	sf.chDivWar <- 1
+func (сам *DivWar) run() {
+	сам.chDivWar <- 1
 	for {
 		select {
-		case <-sf.bot.Кнт().Done():
+		case <-сам.bot.Кнт().Done():
 			return
-		case <-sf.ВремяОстат().КаналСиг(): // Время обновить данные по сражению
-			sf.findTimeCount()
-			sf.upDivWar()
-		case <-sf.chDivWar: // Сигнал к началу сражения
-			sf.block.Lock()
-			if sf.divon != nil {
+		case <-сам.ВремяОстат().КаналСиг(): // Время обновить данные по сражению
+			сам.findTimeCount()
+			сам.upDivWar()
+		case <-сам.chDivWar: // Сигнал к началу сражения
+			сам.block.Lock()
+			if сам.divon != nil {
 				continue
 			}
-			sf.alarm.Уст(1)
-			sf.sound.Play()
-			go sf.DivWar()               // Запустить цикл непосредственного сражения
+			сам.alarm.Уст(1)
+			сам.sound.Play()
+			go сам.DivWar()              // Запустить цикл непосредственного сражения
 			time.Sleep(time.Second * 10) // Задержка для звука на странице
-			sf.alarm.Уст(0)
+			сам.alarm.Уст(0)
 		}
 	}
 }
 
 // Ищет время до начала битвы дивизий
-func (sf *DivWar) findTimeCount() {
-	if err := sf.net.Обновить(); err != nil { // Здесь может уже обратный отсчёт перед сражением
-		sf.chDivWar <- 1
+func (сам *DivWar) findTimeCount() {
+	if err := сам.net.Обновить(); err != nil { // Здесь может уже обратный отсчёт перед сражением
+		сам.chDivWar <- 1
 		return
 	}
 	var (
 		strOut    string
-		lstDivWar = sf.СписПолучить()
-		isFind    bool
+		lstDivWar = сам.СписПолучить()
+		iсамind   bool
 		ind       int
 	)
 	for ind, strOut = range lstDivWar {
 		if strings.Contains(strOut, `до начала: `) {
 			ind++
 			strOut = lstDivWar[ind]
-			isFind = true
+			iсамind = true
 			break
 		}
 		if strings.Contains(strOut, `>ОБЫЧНЫЕ<`) { // Это уже битва
-			sf.chDivWar <- 1
+			сам.chDivWar <- 1
 			return
 		}
 	}
-	if !isFind { // Битва дивизий уже идёт
-		sf.chDivWar <- 1
+	if !iсамind { // Битва дивизий уже идёт
+		сам.chDivWar <- 1
 		return
 	}
 	lstTime := strings.Split(strOut, `<span>`)
 	strTime := lstTime[1]
 	lstTime = strings.Split(strTime, `</span>`)
 	strTime = lstTime[0]
-	if err := sf.Уст(alias.Время(strTime)); err != nil {
+	if err := сам.Уст(alias.Время(strTime)); err != nil {
 		// log._rintf("WARN DivWar.findTimeCount(): при установке времени ожидания битвы дивизий(%v)\n\terr=%v\n", strTime, err)
 		return
 	}
@@ -162,11 +162,11 @@ func (сам *DivWar) upDivWar() {
 	var (
 		strOut    string
 		lstDivWar = сам.СписПолучить()
-		isFind    bool
+		iсамind   bool
 	)
 	for _, strOut = range lstDivWar {
 		if strings.Contains(strOut, `>Взвод, подъем! В атаку!<`) {
-			isFind = true
+			iсамind = true
 			break
 		}
 		if strings.Contains(strOut, `<div class="white medium cntr bold mb5">Вы в рядах участников</div>`) {
@@ -174,7 +174,7 @@ func (сам *DivWar) upDivWar() {
 			return
 		}
 	}
-	if !isFind {
+	if !iсамind {
 		return
 	}
 	// Найдено приглашение на участие
@@ -194,30 +194,30 @@ func (сам *DivWar) upDivWar() {
 }
 
 // Ведёт сражение
-func (sf *DivWar) DivWar() {
+func (сам *DivWar) DivWar() {
 	defer func() {
-		sf.divon = nil
-		sf.block.Unlock()
-		if err := sf.Секция.ОбратВремяУст("01"); err != nil {
+		сам.divon = nil
+		сам.block.Unlock()
+		if err := сам.Секция.ОбратВремяУст("01"); err != nil {
 			panic(fmt.Errorf("DivWar.DivWar(): при установке CountDown, err=\n\t%w", err))
 		}
 		// log.Printf("INFO DivWar.DivWar(): сражение завершено\n")
 	}()
 	var err error
-	sf.divon, err = divwaron.NewDivWarOn(sf.bot) // IDivWarOn (онлайн)
+	сам.divon, err = divwaron.NewDivWarOn(сам.bot) // IDivWarOn (онлайн)
 	if err != nil {
 		// log._rintf("ERRO DivWar.DivWarOn(): при создании IDivWarOn, err=\n\t%v\n", err)
 		time.Sleep(time.Millisecond * 250)
 		return
 	}
 	// Цикл ожидания окончания сражения
-	for !sf.divon.ЕслиКонец().Получ() {
+	for !сам.divon.ЕслиКонец().Получ() {
 		time.Sleep(time.Second * 1)
 	}
 
 }
 
 // Alarm -- возвращает признак начала сражения (для браузера)
-func (sf *DivWar) Alarm() types.ИСтатПарам {
-	return sf.alarm
+func (сам *DivWar) Alarm() types.ИСтатПарам {
+	return сам.alarm
 }

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

@@ -23,9 +23,9 @@ func NewDivWarNet(bot types.ИБот) (*DivWarNet, error) {
 		return nil, fmt.Errorf("NewDivWarNet(): IServBpt == nil")
 	}
 
-	sf := &DivWarNet{
+	сам := &DivWarNet{
 		// SectionNet: sectionnet.NewSectionNet(server, bot, ..., "https://wartank.ru/bitva"),
 		bot: bot,
 	}
-	return sf, nil
+	return сам, nil
 }

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

@@ -42,7 +42,7 @@ func NewDivWarOn(bot types.ИБот) (*DivWarOn, error) {
 		return nil, fmt.Errorf("NewDivWarOn(): IBot == nil")
 	}
 	ctxDivWar, fnCancelDivWar := context.WithTimeout(bot.Кнт(), time.Second*305)
-	sf := &DivWarOn{
+	сам := &DivWarOn{
 		bot:            bot,
 		ctxDivWar:      ctxDivWar,
 		fnCancelDivWar: fnCancelDivWar,
@@ -52,74 +52,74 @@ func NewDivWarOn(bot types.ИБот) (*DivWarOn, error) {
 	}
 	var err error
 	{ // ISection (ожидание)
-		sf.Секция, err = section.НовСекция(bot, "Ожидание битвы дивизий", `<title>Сражения</title>`)
+		сам.Секция, err = section.НовСекция(bot, "Ожидание битвы дивизий", `<title>Сражения</title>`)
 		if err != nil {
 			return nil, fmt.Errorf("NewDivWarOn(): in create *Section, err=\n\t%w", err)
 		}
 	}
-	sf.сеть, err = scene_net.НовСекцияСеть(sf, "https://wartank.ru/pve")
+	сам.сеть, err = scene_net.НовСекцияСеть(сам, "https://wartank.ru/pve")
 	if err != nil {
 		return nil, fmt.Errorf("NewDivWarOn(): in create ИСценаСеть, err=\n\t%w", err)
 	}
-	if sf.checkEnd() {
+	if сам.checkEnd() {
 		return nil, fmt.Errorf("NewDivWarOn(): нет страницы для сражения")
 	}
-	go sf.makeTick()
-	go sf.run()
-	return sf, nil
+	go сам.makeTick()
+	go сам.run()
+	return сам, nil
 }
 
 // Ежесекудный тик
-func (sf *DivWarOn) makeTick() {
+func (сам *DivWarOn) makeTick() {
 	defer func() {
-		close(sf.chTick)
-		sf.isEnd.Уст()
+		close(сам.chTick)
+		сам.isEnd.Уст()
 	}()
-	for !sf.isEnd.Получ() {
+	for !сам.isEnd.Получ() {
 		select {
-		case <-sf.bot.Кнт().Done(): // Отмена контекста приложения
+		case <-сам.bot.Кнт().Done(): // Отмена контекста приложения
 			return
-		case <-sf.ctxDivWar.Done(): // Битва закончилась
+		case <-сам.ctxDivWar.Done(): // Битва закончилась
 			return
 		default:
-			if sf.isEnd.Получ() {
+			if сам.isEnd.Получ() {
 				return
 			}
-			sf.chTick <- 1
+			сам.chTick <- 1
 			time.Sleep(time.Second * 1)
 		}
 	}
 }
 
 // запускает сражение
-func (sf *DivWarOn) run() {
+func (сам *DivWarOn) run() {
 	// defer log._rintf("DivWarOn.run(): сражение завершено\n")
 	{ // Подготовка к сражению
 		var err error
-		sf.shot, err = shot.NewShot(sf, sf.login) // Объект выстрела
+		сам.shot, err = shot.NewShot(сам, сам.login) // Объект выстрела
 		if err != nil {
 			// log._rintf("ERRO DivWarOn.Run(): при создании выстрела танка, err=\n\t%v\n", err)
 			return
 		}
-		sf.health, err = health.NewHealth(sf, sf.shot.IsEnd(), sf.login)
+		сам.health, err = health.NewHealth(сам, сам.shot.IsEnd(), сам.login)
 		if err != nil {
 			// log._rintf("ERRO DivWarOn.Run(): при создании здоровья танка, err=\n\t%v\n", err)
-			sf.shot.IsEnd().Сброс()
+			сам.shot.IsEnd().Сброс()
 			return
 		}
-		sf.manevr, err = manevr.NewManevr(sf, sf.shot.IsEnd())
+		сам.manevr, err = manevr.NewManevr(сам, сам.shot.IsEnd())
 		if err != nil {
 			// log._rintf("ERRO DivWarOn.Run(): при создании маневра танка, err=\n\t%v\n", err)
-			sf.shot.IsEnd().Сброс()
+			сам.shot.IsEnd().Сброс()
 			return
 		}
 	}
 	for { // Рабочий цикл сражения
 		select {
-		case <-sf.ctxDivWar.Done():
+		case <-сам.ctxDivWar.Done():
 			return
-		case <-sf.ВремяОстат().КаналСиг():
-			if sf.checkEnd() {
+		case <-сам.ВремяОстат().КаналСиг():
+			if сам.checkEnd() {
 				return
 			}
 		}
@@ -127,62 +127,62 @@ func (sf *DivWarOn) run() {
 }
 
 // Сеть -- возвращает сетевой компонент секции
-func (sf *DivWarOn) Сеть() types.ИСценаСеть {
-	return sf.сеть
+func (сам *DivWarOn) Сеть() types.ИСценаСеть {
+	return сам.сеть
 }
 
 // Проверяет окончание сражения
-func (sf *DivWarOn) checkEnd() bool {
+func (сам *DivWarOn) checkEnd() bool {
 	defer func() {
-		if sf.isEnd.Получ() {
-			sf.fnCancelDivWar()
+		if сам.isEnd.Получ() {
+			сам.fnCancelDivWar()
 			// log._rintf("DivWarOn.checkEnd(): сражение завершено\n")
 		}
 	}()
 
-	if err := sf.сеть.Обновить(); err != nil {
+	if err := сам.сеть.Обновить(); err != nil {
 		// log._rintf("WARN DivWarOn.checkEnd(): при обновлении lstDivWarOn, err=\n\t%v\n", err)
-		sf.isEnd.Уст()
-		sf.fnCancelDivWar()
+		сам.isEnd.Уст()
+		сам.fnCancelDivWar()
 		return true
 	}
-	lstDivWarOn := sf.СписПолучить()
+	lstDivWarOn := сам.СписПолучить()
 	for _, strOut := range lstDivWarOn {
 		if strings.Contains(strOut, `" class="simple-but gray"><span><span>ОБЫЧНЫЕ</span></span></a>`) {
-			sf.isEnd.Сброс()
+			сам.isEnd.Сброс()
 			return false
 		}
 	}
-	sf.isEnd.Уст()
-	sf.fnCancelDivWar()
+	сам.isEnd.Уст()
+	сам.fnCancelDivWar()
 	return true
 }
 
 // ЕслиКонец -- возвращает признак окончания сражения (интерфейс)
-func (sf *DivWarOn) ЕслиКонец() *safe_bool.БезопБул {
-	return sf.isEnd
+func (сам *DivWarOn) ЕслиКонец() *safe_bool.БезопБул {
+	return сам.isEnd
 }
 
-func (sf *DivWarOn) Манёвр() {
-	if sf.manevr == nil {
+func (сам *DivWarOn) Манёвр() {
+	if сам.manevr == nil {
 		return
 	}
-	if sf.manevr.IsReady() {
-		sf.manevr.Manevr()
+	if сам.manevr.IsReady() {
+		сам.manevr.Manevr()
 	}
 }
 
 // ВыстрелБлок -- признак запрета стрельбы при слабом здоровье
-func (sf *DivWarOn) ВыстрелБлок() *safe_bool.БезопБул {
-	return sf.isMasking
+func (сам *DivWarOn) ВыстрелБлок() *safe_bool.БезопБул {
+	return сам.isMasking
 }
 
 // Ctx -- возвращает контекст отмены сражения
-func (sf *DivWarOn) Ctx() context.Context {
-	return sf.ctxDivWar
+func (сам *DivWarOn) Ctx() context.Context {
+	return сам.ctxDivWar
 }
 
 // CancelBattle - -вызов функции отмены контекста сражения
-func (sf *DivWarOn) CancelBattle() {
-	sf.fnCancelDivWar()
+func (сам *DivWarOn) CancelBattle() {
+	сам.fnCancelDivWar()
 }

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

@@ -24,16 +24,16 @@ func NewDivWarSound() *DivWarSound {
 }
 
 // Play -- играет музончик, если можно
-func (sf *DivWarSound) Play() {
-	if sf.isPlay.Get() {
+func (сам *DivWarSound) Play() {
+	if сам.isPlay.Get() {
 		return
 	}
-	go sf.play()
+	go сам.play()
 }
 
 // Проигрывает экслюзивно в отдельном потоке звук
-func (sf *DivWarSound) play() {
-	sf.isPlay.Set()
+func (сам *DivWarSound) play() {
+	сам.isPlay.Set()
 	val := 7
 	for val > 0 {
 		sound.DivWar()
@@ -45,5 +45,5 @@ func (sf *DivWarSound) play() {
 		val--
 		time.Sleep(time.Second * 1)
 	}
-	sf.isPlay.Reset()
+	сам.isPlay.Reset()
 }

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

@@ -20,22 +20,22 @@ func NewIsPlay() *IsPlay {
 }
 
 // Get -- возвращает хранимое состояние
-func (sf *IsPlay) Get() bool {
-	sf.block.RLock()
-	defer sf.block.RUnlock()
-	return sf.val
+func (сам *IsPlay) Get() bool {
+	сам.block.RLock()
+	defer сам.block.RUnlock()
+	return сам.val
 }
 
 // Set -- устанавливает хранимое состояние
-func (sf *IsPlay) Set() {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	sf.val = true
+func (сам *IsPlay) Set() {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	сам.val = true
 }
 
 // Reset -- сбрасывает хранимое состояние
-func (sf *IsPlay) Reset() {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	sf.val = false
+func (сам *IsPlay) Reset() {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	сам.val = false
 }

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

@@ -50,7 +50,7 @@ func NewHealth(divwar types.ИДивизияВойнаДействие, isEnd *s
 			return nil, fmt.Errorf("NewHealth(): login is empty")
 		}
 	}
-	sf := &Health{
+	сам := &Health{
 		ИДивизияВойнаДействие: divwar,
 		fnCancel:   divwar.CancelBattle,
 		ctxBattle:  divwar.Ctx(),
@@ -62,110 +62,110 @@ func NewHealth(divwar types.ИДивизияВойнаДействие, isEnd *s
 		login:      login,
 		chTick:     make(chan int, 2),
 	}
-	go sf.makeTik()
-	go sf.run()
-	return sf, nil
+	go сам.makeTik()
+	go сам.run()
+	return сам, nil
 }
 
 // Отправляе ттики с заданным равным интервалом
-func (sf *Health) makeTik() {
+func (сам *Health) makeTik() {
 	defer func() {
-		sf.CancelBattle()
-		close(sf.chTick)
+		сам.CancelBattle()
+		close(сам.chTick)
 		// log._rintf("Health.makeTick(): сражение завершёно\n")
 	}()
 	count := 0
 	repairTime := 0
 	for {
 		select {
-		case <-sf.ctxBattle.Done():
+		case <-сам.ctxBattle.Done():
 			return
 		default:
-			if sf.IsDeath() {
+			if сам.IsDeath() {
 				return
 			}
-			if sf.repairTime.Get() == repairTime {
+			if сам.repairTime.Get() == repairTime {
 				count++
 			} else {
-				repairTime = sf.repairTime.Get()
+				repairTime = сам.repairTime.Get()
 				count = 0
 			}
 			if count > 90 {
 				return
 			}
 		}
-		sf.chTick <- 1
+		сам.chTick <- 1
 		time.Sleep(time.Second * 1)
-		sf.repairTime.Dec()
+		сам.repairTime.Dec()
 	}
 }
 
 // Главный цикл обработки здоровья в сражении
-func (sf *Health) run() {
+func (сам *Health) run() {
 	for {
 		select {
-		case <-sf.ctxBattle.Done():
-			sf.isEnd.Уст()
+		case <-сам.ctxBattle.Done():
+			сам.isEnd.Уст()
 			return
-		case <-sf.chTick:
-			if err := sf.findHealth(); err != nil { // Найти свой здоровье
+		case <-сам.chTick:
+			if err := сам.findHealth(); err != nil { // Найти свой здоровье
 				// log._rintf("ERRO Health.run(): при попытке найти здоровье, err=\n\t%v\n", err)
 			}
-			sf.findRepairTime()
-			if sf.ВыстрелБлок().Получ() {
-				if sf.isRepair.Получ() {
-					go sf.repair()
+			сам.findRepairTime()
+			if сам.ВыстрелБлок().Получ() {
+				if сам.isRepair.Получ() {
+					go сам.repair()
 				}
 				continue
 			}
-			if sf.isRepair.Получ() {
-				go sf.repair()
+			if сам.isRepair.Получ() {
+				go сам.repair()
 			}
 		}
 	}
 }
 
 // Full -- возвращает объект полного здоровья танка
-func (sf *Health) Full() int {
-	return sf.full.Get()
+func (сам *Health) Full() int {
+	return сам.full.Get()
 }
 
 // IsDeath -- возвращает признак мертвичины танка
-func (sf *Health) IsDeath() bool {
-	if sf.isEnd.Получ() {
-		sf.fnCancel()
+func (сам *Health) IsDeath() bool {
+	if сам.isEnd.Получ() {
+		сам.fnCancel()
 		return true
 	}
-	lstBattle := sf.СписПолучить()
+	lstBattle := сам.СписПолучить()
 	for _, strOut := range lstBattle {
 		if strings.Contains(strOut, `>Ваш танк подбит.`) {
 			// log._rintf("INFO Health.repair(): танк подбит\n")
-			sf.temp.Set(0)
-			sf.isEnd.Уст()
-			sf.CancelBattle()
+			сам.temp.Set(0)
+			сам.isEnd.Уст()
+			сам.CancelBattle()
 			return true
 		}
 	}
-	return sf.isEnd.Получ()
+	return сам.isEnd.Получ()
 }
 
 // Ищет время восстановления ремки
-func (sf *Health) findRepairTime() {
+func (сам *Health) findRepairTime() {
 	defer func() {
-		if sf.repairTime.IsReady() {
+		if сам.repairTime.IsReady() {
 			return
 		}
-		if sf.repairTime.IsChange() {
-			// log._rintf("INFO Health.findRepair(): до ремки=%v\n", sf.repairTime.Get())
+		if сам.repairTime.IsChange() {
+			// log._rintf("INFO Health.findRepair(): до ремки=%v\n", сам.repairTime.Get())
 		}
 	}()
-	if sf.repairTime.IsReady() {
+	if сам.repairTime.IsReady() {
 		return
 	}
 	var (
 		strOut    string
-		lstBattle = sf.СписПолучить()
-		isFind    bool
+		lstBattle = сам.СписПолучить()
+		iсамind   bool
 		ind       int
 	)
 	// <a href="pve?19-14.ILinkListener-currentControl-repairLink" class="simple-but blue"><span><span>12 секунд</span></span></a>
@@ -175,11 +175,11 @@ func (sf *Health) findRepairTime() {
 			continue
 		}
 		if strings.Contains(strOut, ` секунд</span></span></a>`) {
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind {
+	if !iсамind {
 		return
 	}
 	strOut = lstBattle[ind]
@@ -187,35 +187,35 @@ 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.Уст()
-		sf.CancelBattle()
+		сам.isEnd.Уст()
+		сам.CancelBattle()
 		return
 	}
 	strTime := lstTime[1]
 	lstTime = strings.Split(strTime, ` секунд</span></span></a>`)
 	strTime = lstTime[0]
-	if err := sf.repairTime.Set(strTime); err != nil {
+	if err := сам.repairTime.Set(strTime); err != nil {
 		// log._rintf("ERRO Health.findRepair(): при установке времени восстановления ремки, err=\n\t%v\n", err)
 	}
 }
 
 // Восстановливает здоровье (~)
-func (sf *Health) repair() {
+func (сам *Health) repair() {
 	var (
-		strOut       string
-		lstBattleOn  = sf.СписПолучить()
-		isFindRepair bool
-		ind          int
+		strOut        string
+		lstBattleOn   = сам.СписПолучить()
+		iсамindRepair bool
+		ind           int
 	)
 	// <span>Ремкомплект</span>
 	// <a href="pve?19-14.ILinkListener-currentControl-repairLink" class="simple-but blue"><span><span>Ремкомплект</span></span></a>
 	for ind, strOut = range lstBattleOn {
 		if strings.Contains(strOut, `<span>Ремкомплект</span>`) {
-			isFindRepair = true
+			iсамindRepair = true
 			break
 		}
 	}
-	if !isFindRepair {
+	if !iсамindRepair {
 		return
 	}
 	strOut = lstBattleOn[ind]
@@ -224,17 +224,17 @@ func (sf *Health) repair() {
 	strLink := lstLink[1]
 	lstLink = strings.Split(strLink, `" class="simple-but blue"><span><span>Ремкомплект</span></span></a>`)
 	strLink = "https://wartank.ru/" + lstLink[0]
-	lstBattleOn, err := sf.Сеть().Get(strLink)
+	lstBattleOn, err := сам.Сеть().Get(strLink)
 	if err != nil {
 		// log._rintf("ERRO Health.repair(): при выполнении GET-команды ремонта, err=\n\t%v\n", err)
-		sf.isEnd.Уст()
-		sf.CancelBattle()
+		сам.isEnd.Уст()
+		сам.CancelBattle()
 		return
 	}
-	if err = sf.СтрОбновить(lstBattleOn); err != nil {
+	if err = сам.СтрОбновить(lstBattleOn); err != nil {
 		// log._rintf("ERRO Health.repair(): при обновлении lstBattle, err=\n\t%v\n", err)
-		sf.isEnd.Уст()
-		sf.CancelBattle()
+		сам.isEnd.Уст()
+		сам.CancelBattle()
 		return
 	}
 	// sound.Repair()
@@ -242,29 +242,29 @@ func (sf *Health) repair() {
 }
 
 // Ищет своё здоровье (~)
-func (sf *Health) findHealth() error {
+func (сам *Health) findHealth() error {
 	var (
 		ind       int
 		strOut    string
-		isFind    bool
-		lstBattle = sf.СписПолучить()
+		iсамind   bool
+		lstBattle = сам.СписПолучить()
 	)
 	if len(lstBattle) == 0 { // Принудительно обновим сражение
-		if err := sf.Сеть().Обновить(); err != nil {
-			sf.isEnd.Уст()
-			sf.fnCancel()
+		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="`+sf.login+`"`) {
-			isFind = true
+		if strings.Contains(strOut, `alt="`+сам.login+`"`) {
+			iсамind = true
 			break
 		}
 	}
-	if !isFind { // Свой танк не найден
-		sf.isEnd.Уст()
-		sf.fnCancel()
+	if !iсамind { // Свой танк не найден
+		сам.isEnd.Уст()
+		сам.fnCancel()
 		return fmt.Errorf("Health.findHealth(): своё здоровье не найдено")
 	}
 	// Свой танк найден, ищем здоровье
@@ -276,83 +276,83 @@ func (sf *Health) findHealth() error {
 	strHealth = lstHealth[0]
 	iHealth, err := strconv.Atoi(strHealth)
 	if err != nil {
-		sf.isEnd.Уст()
-		sf.CancelBattle()
+		сам.isEnd.Уст()
+		сам.CancelBattle()
 		return fmt.Errorf("Health.findHealth(): здоровье(%v) не число, err=%w", strHealth, err)
 	}
-	sf.setHealth(iHealth)
+	сам.setHealth(iHealth)
 	return nil
 }
 
 // setHealth -- устанавливает текущее здоровье
-func (sf *Health) setHealth(val int) {
+func (сам *Health) setHealth(val int) {
 	if val < 0 {
 		// log._rintf("WARN Health.setHealth(): кривое значение здоровья танка(%v)\n", val)
 		val = 0
 	}
 
-	if val > sf.full.Get() {
-		// log._rintf("WARN Health.setHealth(): кривое текущее здоровье, %v/%v\n", val, sf.full.Get())
-		sf.full.Set(val)
-		sf.temp.Set(val)
-		sf.deltaOld = 0
-		sf.ВыстрелБлок().Сброс()
-		sf.isRepair.Сброс()
+	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 := sf.temp.Get() - val
+	delta := сам.temp.Get() - val
 	if delta > 0 { // Дельта будет больше нуля, если только
-		if delta != sf.deltaOld {
+		if delta != сам.deltaOld {
 			// log._rintf("INFO Health.setHealth(): потеря здоровья=%v/%v\n", -delta, val)
-			sf.deltaOld = delta
-			sf.temp.Set(val)
+			сам.deltaOld = delta
+			сам.temp.Set(val)
 		}
 	}
 
 	switch {
-	case sf.isEnd.Получ():
-		sf.temp.Set(0)
-		sf.isEnd.Уст()
-		sf.CancelBattle()
+	case сам.isEnd.Получ():
+		сам.temp.Set(0)
+		сам.isEnd.Уст()
+		сам.CancelBattle()
 		return
 	case val == 0:
-		sf.temp.Set(0)
-		sf.isEnd.Уст()
-		sf.CancelBattle()
+		сам.temp.Set(0)
+		сам.isEnd.Уст()
+		сам.CancelBattle()
 		return
 	case val <= 500: // Запретить стрельбу
-		sf.ВыстрелБлок().Уст() // Установить запрет стрельбы пока слабое здоровье
-		sf.isRepair.Уст()
+		сам.ВыстрелБлок().Уст() // Установить запрет стрельбы пока слабое здоровье
+		сам.isRepair.Уст()
 		// log._rintf("WARN Health.setHealth(): низкий уровень здоровья(%v)\n", val)
-		sf.Манёвр()
+		сам.Манёвр()
 	case val > 500: // Разрешить стрельбы
-		sf.ВыстрелБлок().Сброс()
-		sf.isRepair.Сброс()
-		if delta > sf.full.Get()*4/10 { // Проверить на критичность падения здоровья на 40%
+		сам.ВыстрелБлок().Сброс()
+		сам.isRepair.Сброс()
+		if delta > сам.full.Get()*4/10 { // Проверить на критичность падения здоровья на 40%
 			// log._rintf("WARN Health.setHealth(): большая разовая потеря здоровья(%v)\n", delta)
-			sf.Манёвр()
-			sf.isRepair.Уст()
+			сам.Манёвр()
+			сам.isRepair.Уст()
 			return
 		}
 	}
 
-	isMask := sf.ВыстрелБлок().Получ()
+	isMask := сам.ВыстрелБлок().Получ()
 	switch isMask {
 	case true:
-		sf.countLow++
-		if sf.countLow >= 200 {
-			sf.isEnd.Уст()
-			sf.CancelBattle()
+		сам.countLow++
+		if сам.countLow >= 200 {
+			сам.isEnd.Уст()
+			сам.CancelBattle()
 			return
 		}
 	default:
-		sf.countLow = 0
+		сам.countLow = 0
 	}
-	if val == sf.full.Get() {
-		sf.temp.Set(val)
-		sf.isRepair.Сброс()
-		sf.ВыстрелБлок().Сброс()
-		sf.countLow = 0
+	if val == сам.full.Get() {
+		сам.temp.Set(val)
+		сам.isRepair.Сброс()
+		сам.ВыстрелБлок().Сброс()
+		сам.countLow = 0
 	}
 }

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

@@ -20,27 +20,27 @@ func NewHealthTime() *HealthTime {
 }
 
 // Get -- возвращает хранимое временное здоровье
-func (sf *HealthTime) Get() int {
-	sf.block.RLock()
-	defer sf.block.RUnlock()
-	return sf.val
+func (сам *HealthTime) Get() int {
+	сам.block.RLock()
+	defer сам.block.RUnlock()
+	return сам.val
 }
 
 // IsZero -- возвращает истину, если значение обнулено
-func (sf *HealthTime) IsZero() bool {
-	sf.block.RLock()
-	defer sf.block.RUnlock()
-	return sf.val == 0
+func (сам *HealthTime) IsZero() bool {
+	сам.block.RLock()
+	defer сам.block.RUnlock()
+	return сам.val == 0
 }
 
 // Set -- устанавливает значение по требованию
-func (sf *HealthTime) Set(val int) {
-	sf.block.Lock()
-	defer sf.block.Unlock()
+func (сам *HealthTime) Set(val int) {
+	сам.block.Lock()
+	defer сам.block.Unlock()
 	if val < 0 {
 		// log._rintf("WARN HealthTime.Set(): отрицательное значение(%v)\n", val)
-		sf.val = 0
+		сам.val = 0
 		return
 	}
-	sf.val = val
+	сам.val = val
 }

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

@@ -23,23 +23,23 @@ func NewRepairTime() *RepairTime {
 }
 
 // Get -- возвращает хранимое значение времени
-func (sf *RepairTime) Get() int {
-	sf.block.RLock()
-	defer sf.block.RUnlock()
-	return sf.val
+func (сам *RepairTime) Get() int {
+	сам.block.RLock()
+	defer сам.block.RUnlock()
+	return сам.val
 }
 
 // GetOld -- возвращает хранимое старое значение времени
-func (sf *RepairTime) GetOld() int {
-	sf.block.RLock()
-	defer sf.block.RUnlock()
-	return sf.valOld
+func (сам *RepairTime) GetOld() int {
+	сам.block.RLock()
+	defer сам.block.RUnlock()
+	return сам.valOld
 }
 
 // Set -- устанавливает хранимое время восстановления ремки
-func (sf *RepairTime) Set(val string) error {
-	sf.block.Lock()
-	defer sf.block.Unlock()
+func (сам *RepairTime) Set(val string) error {
+	сам.block.Lock()
+	defer сам.block.Unlock()
 	iVal, err := strconv.Atoi(val)
 	if err != nil {
 		return fmt.Errorf("RepairTime.Set(): val(%v) не число, err=%w", val, err)
@@ -47,31 +47,31 @@ func (sf *RepairTime) Set(val string) error {
 	if iVal < 0 {
 		return fmt.Errorf("RepairTime.Set(): val(%v) < 0", iVal)
 	}
-	sf.valOld = sf.val
-	sf.val = iVal
+	сам.valOld = сам.val
+	сам.val = iVal
 	return nil
 }
 
 // Dec -- уменьшает на секунду время восстановления
-func (sf *RepairTime) Dec() {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	if sf.val > 0 {
-		sf.valOld = sf.val
-		sf.val--
+func (сам *RepairTime) Dec() {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	if сам.val > 0 {
+		сам.valOld = сам.val
+		сам.val--
 	}
 }
 
 // IsReady -- возвращает признак готовности восстановления
-func (sf *RepairTime) IsReady() bool {
-	sf.block.RLock()
-	defer sf.block.RUnlock()
-	return sf.val == 0
+func (сам *RepairTime) IsReady() bool {
+	сам.block.RLock()
+	defer сам.block.RUnlock()
+	return сам.val == 0
 }
 
 // IsChange -- возвращает признак изменения здоровья после присвоения
-func (sf *RepairTime) IsChange() bool {
-	sf.block.RLock()
-	defer sf.block.RUnlock()
-	return sf.val == sf.valOld
+func (сам *RepairTime) IsChange() bool {
+	сам.block.RLock()
+	defer сам.block.RUnlock()
+	return сам.val == сам.valOld
 }

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

@@ -22,22 +22,22 @@ func NewIsManevr() *IsManevr {
 }
 
 // Get -- возвращает хранимое состояние
-func (sf *IsManevr) Get() bool {
-	sf.block.RLock()
-	defer sf.block.RUnlock()
-	return sf.val
+func (сам *IsManevr) Get() bool {
+	сам.block.RLock()
+	defer сам.block.RUnlock()
+	return сам.val
 }
 
 // Set -- устанавливает хранимое состояние
-func (sf *IsManevr) Set() {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	sf.val = true
+func (сам *IsManevr) Set() {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	сам.val = true
 }
 
 // Reset -- сбрасывает хранимое состояние
-func (sf *IsManevr) Reset() {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	sf.val = false
+func (сам *IsManevr) Reset() {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	сам.val = false
 }

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

@@ -42,7 +42,7 @@ func NewManevr(divwar types.ИДивизияВойнаДействие, isDivWar
 	if isDivWar == nil {
 		return nil, fmt.Errorf("NewManevr(): isBattle is nil")
 	}
-	sf := &Manevr{
+	сам := &Manevr{
 		ИДивизияВойнаДействие: divwar,
 		ctxEnd:     divwar.Ctx(),
 		isEnd:      isDivWar,
@@ -50,65 +50,65 @@ func NewManevr(divwar types.ИДивизияВойнаДействие, isDivWar
 		manevrTime: repairtime.NewRepairTime(),
 		chTick:     make(chan int, 1),
 	}
-	_ = sf.manevrTime.Set("0") // При запуске боя есть возможность маневрировать
-	go sf.makeTick()
-	go sf.run()
-	return sf, nil
+	_ = сам.manevrTime.Set("0") // При запуске боя есть возможность маневрировать
+	go сам.makeTick()
+	go сам.run()
+	return сам, nil
 }
 
 // Генерирует тик для уменьшения времени ожидания восстановления возможности манёвра
-func (sf *Manevr) makeTick() {
+func (сам *Manevr) makeTick() {
 	defer func() {
-		close(sf.chTick)
+		close(сам.chTick)
 		// log._rintf("Manevr.makeTick(): сражение завершено\n")
 	}()
 	for {
 		select {
-		case <-sf.ctxEnd.Done():
+		case <-сам.ctxEnd.Done():
 			return
 		default:
-			if sf.manevrTime.Get() == 0 {
-				sf.chTick <- 1
+			if сам.manevrTime.Get() == 0 {
+				сам.chTick <- 1
 			}
 
-			sf.manevrTime.Dec()
+			сам.manevrTime.Dec()
 			time.Sleep(time.Second * 1)
 		}
 	}
 }
 
 // Рабочий цикл поиска маневра (~)
-func (sf *Manevr) run() {
-	for range sf.chTick {
-		if !sf.isManevr.Get() {
+func (сам *Manevr) run() {
+	for range сам.chTick {
+		if !сам.isManevr.Get() {
 			continue
 		}
-		sf.findManevrTime()
+		сам.findManevrTime()
 	}
 }
 
 // Ищет время для манёвра
-func (sf *Manevr) findManevrTime() {
+func (сам *Manevr) findManevrTime() {
 	var (
-		isFind      bool
+		iсамind     bool
 		ind         int
-		lstBattleOn = sf.СписПолучить()
+		lstBattleOn = сам.СписПолучить()
 		strOut      string
 	)
 	for ind, strOut = range lstBattleOn {
 		// <a href="pve?4-88.ILinkListener-currentControl-maneuverLink" class="simple-but blue"><span><span>5 секунд</span></span></a>
 		if strings.Contains(strOut, `-currentControl-maneuverLink`) {
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind { // Или манёвр успел восстановиться, или конец сражения
+	if !iсамind { // Или манёвр успел восстановиться, или конец сражения
 		if strings.Contains(strOut, `<span>Маневр</span>`) {
-			_ = sf.manevrTime.Set("0")
+			_ = сам.manevrTime.Set("0")
 			time.Sleep(time.Second * 1)
 			return
 		}
-		if sf.isEnd.Получ() {
+		if сам.isEnd.Получ() {
 			time.Sleep(time.Second * 1)
 			return
 		}
@@ -124,44 +124,44 @@ func (sf *Manevr) findManevrTime() {
 				WithField("lstBattleOn[ind]", strOut).
 				WithField("lstBattleOn[+1]", lstBattleOn[ind+1]).
 				Errorf("Manevr.findManevrTime(): нет двух полей во времени ожидания")
-			sf.isManevr.Reset()
+			сам.isManevr.Reset()
 			time.Sleep(time.Second * 1)
 			return
 		}
 		strTime := lstTime[1]
 		lstTime = strings.Split(strTime, ` секунд</span></span></a>`)
 		strTime = lstTime[0]
-		if err := sf.manevrTime.Set(strTime); err != nil {
+		if err := сам.manevrTime.Set(strTime); err != nil {
 			logrus.WithError(err).Error("Manevr.findManevrTime(): при обновлении времени ожидания манёвра")
-			sf.isManevr.Reset()
+			сам.isManevr.Reset()
 			time.Sleep(time.Second * 1)
 			return
 		}
 	}
-	sf.isManevr.Set()
-	logrus.WithField("время", sf.manevrTime.Get()).Info("Manevr.findManevrTime(): до манёвра")
+	сам.isManevr.Set()
+	logrus.WithField("время", сам.manevrTime.Get()).Info("Manevr.findManevrTime(): до манёвра")
 }
 
 // Manevr -- принудительный манёвр по требованию
-func (sf *Manevr) Manevr() {
+func (сам *Manevr) Manevr() {
 	var (
-		isFind      = false
-		lstBattleOn = sf.СписПолучить()
+		iсамind     = false
+		lstBattleOn = сам.СписПолучить()
 		strOut      = ""
 	)
-	if !sf.isManevr.Get() {
+	if !сам.isManevr.Get() {
 		time.Sleep(time.Second * 1)
 		return
 	}
 	for _, strOut = range lstBattleOn {
 		// <a href="pve?4-21.ILinkListener-currentControl-maneuverLink" class="simple-but blue"><span><span>Маневр</span></span></a>
 		if strings.Contains(strOut, `<span>Маневр</span>`) {
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind { // Либо ждём восстановления манёвра, либо сражение закончилось
-		sf.isManevr.Reset()
+	if !iсамind { // Либо ждём восстановления манёвра, либо сражение закончилось
+		сам.isManevr.Reset()
 		time.Sleep(time.Second * 1)
 		return
 	}
@@ -170,16 +170,16 @@ func (sf *Manevr) Manevr() {
 		strLink := lstLink[1]
 		lstLink = strings.Split(strLink, `" class="simple-but blue"><span><span>Маневр</span></span></a>`)
 		strLink = "https://wartank.ru/" + lstLink[0]
-		lstBattleOn, err := sf.Сеть().Get(strLink)
+		lstBattleOn, err := сам.Сеть().Get(strLink)
 		if err != nil {
 			logrus.WithError(err).Error("Manevr.Manevr(): при выполнении GET-команды маневра")
-			sf.isManevr.Reset()
+			сам.isManevr.Reset()
 			time.Sleep(time.Second * 1)
 			return
 		}
-		if err = sf.СтрОбновить(lstBattleOn); err != nil {
+		if err = сам.СтрОбновить(lstBattleOn); err != nil {
 			logrus.WithError(err).Error("Manevr.Manevr(): при обновлении lstBattle")
-			sf.isManevr.Reset()
+			сам.isManevr.Reset()
 			time.Sleep(time.Second * 1)
 			return
 		}
@@ -188,6 +188,6 @@ func (sf *Manevr) Manevr() {
 }
 
 // IsReady -- возвращает готовность манёвра
-func (sf *Manevr) IsReady() bool {
-	return sf.manevrTime.IsReady()
+func (сам *Manevr) IsReady() bool {
+	return сам.manevrTime.IsReady()
 }

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

@@ -27,27 +27,27 @@ func NewDamage() *Damage {
 }
 
 // Set -- устанавливает урон
-func (sf *Damage) Set(val alias.Урон) {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	if sf.val == 0 { // Первоначальное присвоение
-		sf.val = val
+func (сам *Damage) Set(val alias.Урон) {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	if сам.val == 0 { // Первоначальное присвоение
+		сам.val = val
 		return
 	}
 	switch {
-	case sf.val > val: // Урон уменьшился
-		sf.res = "down"
-	case sf.val < val: // Урон увеличился
-		sf.res = "up"
+	case сам.val > val: // Урон уменьшился
+		сам.res = "down"
+	case сам.val < val: // Урон увеличился
+		сам.res = "up"
 	default: // Урон не изменился
-		sf.res = "none"
+		сам.res = "none"
 	}
-	sf.val = val
+	сам.val = val
 }
 
 // Result -- возвращает результат сравнения урона старого и текущего
-func (sf *Damage) Result() string {
-	sf.block.RLock()
-	defer sf.block.RUnlock()
-	return sf.res
+func (сам *Damage) Result() string {
+	сам.block.RLock()
+	defer сам.block.RUnlock()
+	return сам.res
 }

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

@@ -49,7 +49,7 @@ func NewShot(divWar types.ИДивизияВойнаДействие, login stri
 			return nil, fmt.Errorf("NewShot(): login is empty")
 		}
 	}
-	sf := &Shot{
+	сам := &Shot{
 		ИДивизияВойнаДействие: divWar,
 		ctxEnd:   divWar.Ctx(),
 		recharge: shottime.NewShotTime(),
@@ -59,44 +59,44 @@ func NewShot(divWar types.ИДивизияВойнаДействие, login stri
 		chTick:   make(chan int, 2),
 	}
 	// Установить время перезарядки
-	sf.recharge.Set(6800)
-	go sf.makeTick()
-	go sf.run()
-	return sf, nil
+	сам.recharge.Set(6800)
+	go сам.makeTick()
+	go сам.run()
+	return сам, nil
 }
 
 // Генерирует тики, когда можно стрелять
-func (sf *Shot) makeTick() {
+func (сам *Shot) makeTick() {
 	defer func() {
-		sf.isEnd.Уст()
-		close(sf.chTick)
-		sf.CancelBattle()
+		сам.isEnd.Уст()
+		close(сам.chTick)
+		сам.CancelBattle()
 		// log._rintf("Shot.makeTick(): сражение завершёно\n")
 	}()
 	countMasking := 0
 	for {
 		select {
-		case <-sf.ctxEnd.Done():
+		case <-сам.ctxEnd.Done():
 			return
 		default:
-			if sf.isEnd.Получ() { // Битва закончилась
+			if сам.isEnd.Получ() { // Битва закончилась
 				return
 			}
-			switch sf.ВыстрелБлок().Получ() { // Проверить запрет на стрельбу при слабом здоровье
+			switch сам.ВыстрелБлок().Получ() { // Проверить запрет на стрельбу при слабом здоровье
 			case true:
 				// log._rintf("WARN Shot.run(): запрет на выстрел\n")
 				countMasking++
 				if countMasking >= 200 {
 					return
 				}
-				sf.Манёвр()
+				сам.Манёвр()
 				time.Sleep(time.Millisecond * 500)
 				continue
 			default:
 				countMasking = 0
 			}
-			sf.chTick <- 1 // Здесь же первый выстрел
-			recharge := sf.recharge.Get()
+			сам.chTick <- 1 // Здесь же первый выстрел
+			recharge := сам.recharge.Get()
 			// log._rintf("INFO Shot.run() перезарядка=%v msec\n", recharge)
 			// Если идёт перезарядка -- постепенно обнуляем время ожидания
 			time.Sleep(time.Millisecond * time.Duration(recharge))
@@ -105,15 +105,15 @@ func (sf *Shot) makeTick() {
 }
 
 // Цикл выстрела (в отдельном потоке)
-func (sf *Shot) run() {
+func (сам *Shot) run() {
 	for {
 		select {
-		case <-sf.ctxEnd.Done():
+		case <-сам.ctxEnd.Done():
 			return
-		case <-sf.chTick:
+		case <-сам.chTick:
 			// Стрелять можно, стандартное ожидание
-			sf.shot()
-			sf.findDamage()
+			сам.shot()
+			сам.findDamage()
 		}
 	}
 }
@@ -121,73 +121,73 @@ func (sf *Shot) run() {
 // Обновляет возможность выстрела (~)
 //
 //	Вызывается из отдельного потока
-func (sf *Shot) shot() {
-	if err := sf.Сеть().Обновить(); err != nil { // Проверка на непосредственно битву
+func (сам *Shot) shot() {
+	if err := сам.Сеть().Обновить(); err != nil { // Проверка на непосредственно битву
 		// <span>закончилась 00:00:07 назад</span>
 		// log._rintf("ERRO Shot.shot(): при обновлении lstBattleOn, err=\n\t%v\n", err)
-		sf.isEnd.Уст()
-		sf.CancelBattle()
+		сам.isEnd.Уст()
+		сам.CancelBattle()
 		return
 	}
 	var (
 		strOut    string
-		lstBattle = sf.СписПолучить()
-		isFind    bool
+		lstBattle = сам.СписПолучить()
+		iсамind   bool
 		err       error
 	)
 	// <a href="pve?6-26.ILinkListener-currentControl-attackRegularShellLink" class="simple-but gray"><span><span>ОБЫЧНЫЕ</span></span></a>
 	for _, strOut = range lstBattle {
 		if strings.Contains(strOut, `-currentControl-attackRegularShellLink`) {
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind {
+	if !iсамind {
 		// log._rintf("WARN Shot.shot(): не найдены ссылка на выстрел\n")
-		sf.isEnd.Уст()
-		sf.CancelBattle()
+		сам.isEnd.Уст()
+		сам.CancelBattle()
 		return
 	}
 	lstLink := strings.Split(strOut, `<a href="`)
 	strLink := lstLink[1]
 	lstLink = strings.Split(strLink, `" class="simple-but gray"><span><span>ОБЫЧНЫЕ</span></span></a>`)
 	strLink = "https://wartank.ru/" + lstLink[0]
-	lstBattle, err = sf.Сеть().Get(strLink)
+	lstBattle, err = сам.Сеть().Get(strLink)
 	if err != nil {
 		// log._rintf("ERRO Shot.shot(): при исполнении GET-команды выстрела обычным снарядом, err=\n\t%v\n", err)
-		sf.isEnd.Уст()
-		sf.CancelBattle()
+		сам.isEnd.Уст()
+		сам.CancelBattle()
 		return
 	}
-	if err = sf.СтрОбновить(lstBattle); err != nil {
+	if err = сам.СтрОбновить(lstBattle); err != nil {
 		// log._rintf("ERRO Shot.shot(): при обновлении lstBattle, err=\n\t%v\n", err)
-		sf.isEnd.Уст()
-		sf.CancelBattle()
+		сам.isEnd.Уст()
+		сам.CancelBattle()
 		return
 	}
 	// sound.Shot()
-	sf.Манёвр()
+	сам.Манёвр()
 }
 
 // Ищет урон от выстрела
-func (sf *Shot) findDamage() {
+func (сам *Shot) findDamage() {
 	var (
 		ind     = 0
-		isFind  = false
-		lstShot = sf.СписПолучить()
+		iсамind = false
+		lstShot = сам.СписПолучить()
 		strOut  string
 	)
 
 	for ind, strOut = range lstShot {
 		// <span class="yellow1 td_u">prospero tank</span>
-		if strings.Contains(strOut, `<span class="yellow1 td_u">`+sf.login+`</span>`) {
+		if strings.Contains(strOut, `<span class="yellow1 td_u">`+сам.login+`</span>`) {
 			ind += 2
 			strOut = lstShot[ind]
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind { // Возможно был рикошет или манёвр
+	if !iсамind { // Возможно был рикошет или манёвр
 		// log._rintf("WARN Shot.findDamage(): не найден урон от выстрела, strOut=%q, ind=%v\n", strOut, ind)
 		return
 	}
@@ -202,37 +202,37 @@ func (sf *Shot) findDamage() {
 		return
 	}
 	if iDamage <= 0 { // Кривой урон от выстрела
-		sf.recharge.Dec5()
+		сам.recharge.Dec5()
 		// log._rintf("WARN Shot.findDamage(): ошибка в значении урона(%v)\n", iDamage)
 		iDamage = 0
 	}
-	sf.damageSum += alias.Урон(iDamage)
-	// log._rintf("INFO Shot.Damage(): damageSum=%v\n", sf.damageSum)
+	сам.damageSum += alias.Урон(iDamage)
+	// log._rintf("INFO Shot.Damage(): damageSum=%v\n", сам.damageSum)
 	if iDamage < 70 {
-		sf.damage.Set(alias.Урон(iDamage))
-		sf.recharge.Inc210()
+		сам.damage.Set(alias.Урон(iDamage))
+		сам.recharge.Inc210()
 	}
-	// log._rintf("INFO Shot.findDamage(): выстрел=+%v, урон=%v", iDamage, sf.damageSum)
+	// log._rintf("INFO Shot.findDamage(): выстрел=+%v, урон=%v", iDamage, сам.damageSum)
 	if iDamage == 0 {
 		return
 	}
-	sf.setDamage(alias.Урон(iDamage))
+	сам.setDamage(alias.Урон(iDamage))
 }
 
 // setDamage -- обновляет время перезарядки в зависимости от произведённого урона
-func (sf *Shot) setDamage(val alias.Урон) {
-	sf.damage.Set(val)
-	switch sf.damage.Result() {
+func (сам *Shot) setDamage(val alias.Урон) {
+	сам.damage.Set(val)
+	switch сам.damage.Result() {
 	case "none":
-		sf.recharge.Dec5()
+		сам.recharge.Dec5()
 	case "up":
-		sf.recharge.Dec30()
+		сам.recharge.Dec30()
 	case "down":
-		sf.recharge.Inc210()
+		сам.recharge.Inc210()
 	}
 }
 
 // IsEnd -- возвращает объект разрешения стрельбы
-func (sf *Shot) IsEnd() *safe_bool.БезопБул {
-	return sf.isEnd
+func (сам *Shot) IsEnd() *safe_bool.БезопБул {
+	return сам.isEnd
 }

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

@@ -24,53 +24,53 @@ func NewShotTime() *ShotTime {
 }
 
 // Get -- возвращает хранимое время до выстрела
-func (sf *ShotTime) Get() alias.МилСек {
-	sf.block.RLock()
-	defer sf.block.RUnlock()
-	return sf.val
+func (сам *ShotTime) Get() alias.МилСек {
+	сам.block.RLock()
+	defer сам.block.RUnlock()
+	return сам.val
 }
 
 // Dec5 -- уменьшает время до выстрела на 5 мсек
-func (sf *ShotTime) Dec5() {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	sf.val -= 5
-	if sf.val < 0 {
-		sf.val = 0
+func (сам *ShotTime) Dec5() {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	сам.val -= 5
+	if сам.val < 0 {
+		сам.val = 0
 	}
 }
 
 // Dec30 -- уменьшает время до выстрела на 30 мсек
-func (sf *ShotTime) Dec30() {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	sf.val -= 30
-	if sf.val < 0 {
-		sf.val = 0
+func (сам *ShotTime) Dec30() {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	сам.val -= 30
+	if сам.val < 0 {
+		сам.val = 0
 	}
 }
 
 // Inc210 -- увеличивает время до выстрела на 210 мсек
-func (sf *ShotTime) Inc210() {
-	sf.block.Lock()
-	defer sf.block.Unlock()
-	sf.val += 210
+func (сам *ShotTime) Inc210() {
+	сам.block.Lock()
+	defer сам.block.Unlock()
+	сам.val += 210
 }
 
 // IsZero -- возвращает истину, если значение обнулено
-func (sf *ShotTime) IsZero() bool {
-	sf.block.RLock()
-	defer sf.block.RUnlock()
-	return sf.val == 0
+func (сам *ShotTime) IsZero() bool {
+	сам.block.RLock()
+	defer сам.block.RUnlock()
+	return сам.val == 0
 }
 
 // Set -- устанавливает значение по требованию
-func (sf *ShotTime) Set(val alias.МилСек) {
-	sf.block.Lock()
-	defer sf.block.Unlock()
+func (сам *ShotTime) Set(val alias.МилСек) {
+	сам.block.Lock()
+	defer сам.block.Unlock()
 	if val < 0 {
 		logrus.WithField("val", val).Error("ShotTime.Set(): отрицательное значение")
 		return
 	}
-	sf.val = val
+	сам.val = val
 }

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

@@ -27,35 +27,35 @@ func НовТопливо(ангар types.ИАнгар) (*Топливо, error
 	if ош != nil {
 		return nil, fmt.Errorf("NewFuel(): при создании стат топливо, ош=\n\t%w", ош)
 	}
-	sf := &Топливо{
+	сам := &Топливо{
 		ангар:   ангар,
 		топливо: топливо,
 	}
-	return sf, nil
+	return сам, nil
 }
 
 // Run -- должен работать в отдельном потоке, контролит топливо
-func (sf *Топливо) Run() {
+func (сам *Топливо) Run() {
 	count := 0 // Каждые 1500 сек (100 топлива проверять принудительно)
 	for {
 		time.Sleep(time.Second * 15)
-		if sf.топливо.Получ() < 314 {
-			sf.Обновить()
+		if сам.топливо.Получ() < 314 {
+			сам.Обновить()
 			count = 0
 			continue
 		}
 		count++
-		fuel := sf.топливо.Получ()
+		fuel := сам.топливо.Получ()
 		fuel++
-		sf.топливо.Уст(fuel)
+		сам.топливо.Уст(fuel)
 		// log.Printf("Fuel.Run: val=%v\n", fuel)
 	}
 }
 
 // Обновить -- ищет в теле текста ангара топливо
-func (sf *Топливо) Обновить() {
+func (сам *Топливо) Обновить() {
 	// _mt.Println("\tAngarNet.findFuel()")
-	lstAngar := sf.ангар.СписПолучить()
+	lstAngar := сам.ангар.СписПолучить()
 	var strOut string
 	for _, strFuel := range lstAngar {
 		if strings.Contains(strFuel, `<img title="Топливо" `) {
@@ -80,7 +80,7 @@ func (sf *Топливо) Обновить() {
 		// log._rintf("ERRO Fuel.findFuel(): fuel(%v) not number, err=\n\t%v\n", strFuel, err)
 		return
 	}
-	sf.топливо.Уст(iFuel)
+	сам.топливо.Уст(iFuel)
 	if iFuel <= 314 { // Минимальное значение "топливного склада-1" -- 315
 		return
 	}
@@ -88,6 +88,6 @@ func (sf *Топливо) Обновить() {
 }
 
 // Fuel -- возвращает объект сстатическог опараметра топлива
-func (sf *Топливо) Fuel() types.ИСтатПарам {
-	return sf.топливо
+func (сам *Топливо) Fuel() types.ИСтатПарам {
+	return сам.топливо
 }

server/serv_bots/warbot/angar/fuel_attack/fuel_attack.go

@@ -25,11 +25,11 @@ func НовТопливоБой(angar types.ИАнгар) (*ТопливоБой
 	if err != nil {
 		return nil, fmt.Errorf("NewТопливоБой(): in create SectionNet, err=\n\t%w", err)
 	}
-	sf := &ТопливоБой{
+	сам := &ТопливоБой{
 		СценаСеть: sectionNet,
 		ангар:     angar,
 	}
-	return sf, nil
+	return сам, nil
 }
 
 func (сам *ТопливоБой) Пуск() error {
@@ -65,10 +65,10 @@ func (сам *ТопливоБой) пуск() {
 // Получает количество топлива
 
 // Идёт в атаку, если топлива больше cons.ТопливоМин
-func (sf *ТопливоБой) начатьБой() (спискСтрБой []string, err error) {
+func (сам *ТопливоБой) начатьБой() (спискСтрБой []string, err error) {
 	// Получить ссылку на атаку
 	// _mt.Println("\t ТопливоБой.начатьБой()")
-	списАнгар := sf.ангар.СписПолучить()
+	списАнгар := сам.ангар.СписПолучить()
 	var стрАнализ string
 	for _, стрАтак := range списАнгар {
 		if strings.Contains(стрАтак, `<span>В бой!</span>`) {
@@ -84,7 +84,7 @@ func (sf *ТопливоБой) начатьБой() (спискСтрБой []s
 	бойСсылка := списАнгар[1]
 	списАнгар = strings.Split(бойСсылка, `"><span><span>В бой!</span></span></a>`)
 	бойСсылка = "https://wartank.ru/" + списАнгар[0]
-	спискСтрБой, err = sf.Get(бойСсылка)
+	спискСтрБой, err = сам.Get(бойСсылка)
 	if err != nil {
 		return nil, fmt.Errorf("ТопливоБой.начатьБой(): in make GET-request to battle, err=\n\t%w", err)
 	}
@@ -92,7 +92,7 @@ func (sf *ТопливоБой) начатьБой() (спискСтрБой []s
 }
 
 // Выбирает первого более слабого противника и делает первый выстрел
-func (sf *ТопливоБой) выбратьБойСлабый(списСтрБой []string) (списСтрВыстрел1 []string, err error) {
+func (сам *ТопливоБой) выбратьБойСлабый(списСтрБой []string) (списСтрВыстрел1 []string, err error) {
 	// _mt.Println("\tAngarNet.makeSelectBattle()")
 	var стрАнализ string
 	defer func() {
@@ -141,7 +141,7 @@ func (sf *ТопливоБой) выбратьБойСлабый(списСтр
 		списСтрБой = strings.Split(ссылкаБой, `"><img class="tank-img" alt="tank" src="/tankimg?`)
 		ссылкаБой = "https://wartank.ru/" + списСтрБой[0]
 	}
-	списСтрВыстрел1, err = sf.Get(ссылкаБой)
+	списСтрВыстрел1, err = сам.Get(ссылкаБой)
 	if err != nil {
 		return nil, fmt.Errorf("ТопливоБой.makeSelectBattle(): in GET-response select battle tank, err=\n\t%w", err)
 	}

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

@@ -31,36 +31,36 @@ func НовБитваМастеров(бот types.ИБот) (*БитваМас
 		return nil, fmt.Errorf("НовБитваМастеров(): IBot == nil")
 	}
 
-	sf := &БитваМастеров{
+	сам := &БитваМастеров{
 		бот: бот,
 	}
-	return sf, nil
+	return сам, nil
 }
 
 // Run -- запускает в работу битву мастеров
-func (sf *БитваМастеров) Run() error {
+func (сам *БитваМастеров) Run() error {
 	var err error
 	{ // ISection (ожидание)
-		sf.Секция, err = section.НовСекция(sf.бот, "Битва мастеров", `/> Битва мастеров <`)
+		сам.Секция, err = section.НовСекция(сам.бот, "Битва мастеров", `/> Битва мастеров <`)
 		if err != nil {
 			return fmt.Errorf("BatMas.Run(): in create *Section, err=\n\t%w", err)
 		}
 	}
 	{ // Net (ожидание)
-		sf.сеть, err = batmasnet.NewBatMasNet(sf.бот)
+		сам.сеть, err = batmasnet.NewBatMasNet(сам.бот)
 		if err != nil {
 			return fmt.Errorf("BatMas.Run(): при создании BatMasNet, err=\n\t%w", err)
 		}
 	}
-	_ = sf.goBatMas()
+	_ = сам.goBatMas()
 	go func() {
 		for {
 			time.Sleep(time.Second * 10)
 			select {
-			case <-sf.бот.Кнт().Done():
+			case <-сам.бот.Кнт().Done():
 				return
-			case <-sf.ВремяОстат().КаналСиг():
-				if !sf.goBatMas() { // Проверка на начало сражения
+			case <-сам.ВремяОстат().КаналСиг():
+				if !сам.goBatMas() { // Проверка на начало сражения
 					continue
 				}
 			}
@@ -72,53 +72,53 @@ func (sf *БитваМастеров) Run() error {
 // Вычисляет нужно ли идти в битву мастеров
 //
 //	если нужно, то время проверять уже не надо
-func (sf *БитваМастеров) goBatMas() bool {
-	sf.findTimeCount()
-	if !sf.upBattle() {
+func (сам *БитваМастеров) goBatMas() bool {
+	сам.findTimeCount()
+	if !сам.upBattle() {
 		return false
 	}
-	countTime := sf.ВремяОстат().String()
+	countTime := сам.ВремяОстат().String()
 	if countTime > "00:25:00" {
-		if err := sf.ОбратВремяУст(alias.Время(countTime)); err != nil {
+		if err := сам.ОбратВремяУст(alias.Время(countTime)); err != nil {
 			log.Printf("ERRO BatMas.goBatMas(): при установке времени ожидания битвы мастеров(%v)\n\terr=%v\n", countTime, err)
 		}
 		return false
 	}
 
 	// Время меньше 25 сек, надо уточнять (тут возможна ошибка с экраном ожидания)
-	if err := sf.сеть.Обновить(); err != nil {
+	if err := сам.сеть.Обновить(); err != nil {
 		// log._rintf("ERRO Battle.goBattle().fnCountDown(): при обновлении lstBattle, err=\n\t%v\n", err)
 		// Возможно времени уже не осталось
 		return true
 	}
 	// Время ожидания вышло, надо начать атаку
-	if err := sf.ОбратВремяУст("00"); err != nil {
+	if err := сам.ОбратВремяУст("00"); err != nil {
 		log.Printf("ERRO BatMas.goBatMas(): при установке времени ожидания битвы мастеров(0)\n\terr=%v\n", err)
 	}
 	return false
 }
 
 // Ищет время до начала битвы мастеров
-func (sf *БитваМастеров) findTimeCount() {
+func (сам *БитваМастеров) findTimeCount() {
 	var (
 		strOut    string
-		lstBattle = sf.СписПолучить()
-		isFind    bool
+		lstBattle = сам.СписПолучить()
+		iсамind   bool
 	)
 	// Обновление через: 12:02:22
 	for _, strOut = range lstBattle {
 		if strings.Contains(strOut, `Обновление через: `) {
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if isFind { // Ждём начала битвы мастеров
+	if iсамind { // Ждём начала битвы мастеров
 		lstTime := strings.Split(strOut, `Обновление через: `)
 		strTime := lstTime[1]
 		lstTime = strings.Split(strTime, ` (`)
 		strTime = lstTime[0]
 
-		if err := sf.Уст(alias.Время(strTime)); err != nil {
+		if err := сам.Уст(alias.Время(strTime)); err != nil {
 			log.Printf("WARN BatMas.findTimeCount(): при установке времени ожидания битвы мастеров(%v)\n\terr=%v\n", strTime, err)
 		}
 	}
@@ -127,34 +127,34 @@ func (sf *БитваМастеров) findTimeCount() {
 // При необходимости даёт команду на участие в битве мастеров,
 //
 //	вызывается только если есть награда
-func (sf *БитваМастеров) upBattle() bool {
-	if err := sf.сеть.Обновить(); err != nil {
+func (сам *БитваМастеров) upBattle() bool {
+	if err := сам.сеть.Обновить(); err != nil {
 		// log._rintf("ERRO BatMas.upBattle(): при обновлении lstBattle, err=\n\t%v\n", err)
 		return false
 	}
 	// log.Error("BatMas.upBattle(): доделать")
 	// var (
 	// 	strOut    string
-	// 	lstBattle = sf.GetLst()
-	// 	isFind    bool
+	// 	lstBattle = сам.GetLst()
+	// 	iсамind    bool
 	// )
 	// for _, strOut = range lstBattle {
 	// 	if strings.Contains(strOut, `>Взвод, подъем! В атаку!<`) {
-	// 		isFind = true
+	// 		iсамind = true
 	// 		break
 	// 	}
 	// }
-	// if isFind {
+	// if iсамind {
 	// 	lstUp := strings.Split(strOut, `<a class="simple-but border" href="`)
 	// 	linkUp := lstUp[1]
 	// 	lstUp = strings.Split(linkUp, `"><span><span>Взвод, подъем! В атаку!</span></span></a>`)
 	// 	linkUp = "https://wartank.ru/" + lstUp[0]
-	// 	lstBattle, err := sf.net.Get(linkUp)
+	// 	lstBattle, err := сам.net.Get(linkUp)
 	// 	if err != nil {
 	// 		log.WithError(err).Error("Battle.upBattle(): при выполнении GET-команды на подъём в атаку")
 	// 		return false
 	// 	}
-	// 	if err = sf.Update(lstBattle); err != nil {
+	// 	if err = сам.Update(lstBattle); err != nil {
 	// 		log.WithError(err).Error("Battle.upBattle(): при обновлении lstBattle")
 	// 	}
 	// }

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

@@ -23,9 +23,9 @@ func NewBatMasNet(bot types.ИБот) (*BatMasNet, error) {
 		return nil, fmt.Errorf("NewBatMasNet(): IServBot == nil")
 	}
 
-	sf := &BatMasNet{
+	сам := &BatMasNet{
 		// SectionNet: sectionnet.NewSectionNet(server, bot, ..., "https://wartank.ru/pvp"),
 		bot: bot,
 	}
-	return sf, nil
+	return сам, nil
 }

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

@@ -46,50 +46,50 @@ func (сам *Миссии) Пуск() error {
 }
 
 // обрабатывает конвой
-func (sf *Миссии) пуск() {
+func (сам *Миссии) пуск() {
 	time.Sleep(time.Second * 5)
 	for { // Время истекло
 		// time.Sleep(time.Minute * 1)
 		select {
-		case <-sf.бот.Кнт().Done():
+		case <-сам.бот.Кнт().Done():
 			return
 		default:
-			sf.проверНаграда()
+			сам.проверНаграда()
 			time.Sleep(time.Minute * 1)
 		}
 	}
 }
 
 // Забирает всё самое вкусное
-func (sf *Миссии) проверНаграда() {
-	sf.сражениеЗащита()
-	sf.сражениеНаступление()
-	sf.проведиВойну()
-	sf.battle5Fiting()
-	sf.battle6win()
-	sf.battle10Fiting()
-	sf.battleDogFyting()
-	sf.makeResource()
-	sf.kill3tanks()
-	sf.топливоДив()
-	sf.upMan()
+func (сам *Миссии) проверНаграда() {
+	сам.сражениеЗащита()
+	сам.сражениеНаступление()
+	сам.проведиВойну()
+	сам.battle5Fiting()
+	сам.battle6win()
+	сам.battle10Fiting()
+	сам.battleDogFyting()
+	сам.makeResource()
+	сам.kill3tanks()
+	сам.топливоДив()
+	сам.upMan()
 }
 
 // Проверяет награду за уничтожить 3 танка в бою
-func (sf *Миссии) kill3tanks() {
+func (сам *Миссии) kill3tanks() {
 	var (
 		strOut      string
-		lstMissions = sf.СписПолучить()
-		isFind      bool
+		lstMissions = сам.СписПолучить()
+		iсамind     bool
 		ind         int
 	)
 	for ind, strOut = range lstMissions {
 		if strings.Contains(strOut, `Уничтожь в бою 3 танка<br/>`) {
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind {
+	if !iсамind {
 		return
 	}
 	// <a class="simple-but border" href="?70-1.ILinkListener-missions-cc-0-c-awardLink"><span><span>Получить награду</span></span></a>
@@ -102,12 +102,12 @@ func (sf *Миссии) kill3tanks() {
 	strLink := lstLink[1]
 	lstLink = strings.Split(strLink, `"><span><span>Получить награду</span></span></a>`)
 	strLink = "https://wartank.ru/missions/" + lstLink[0]
-	lstMissions, err := sf.сеть.Get(strLink)
+	lstMissions, err := сам.сеть.Get(strLink)
 	if err != nil {
 		// log._rintf("ERRO Миссии.kill3tanks(): при выполнении GET-запроса, err=\n\t%v\n", err)
 		return
 	}
-	if err := sf.СтрОбновить(lstMissions); err != nil {
+	if err := сам.СтрОбновить(lstMissions); err != nil {
 		// log._rintf("ERRO Миссии.kill3tanks(): при обновлении lstMissions, err=\n\t%v\n", err)
 		return
 	}
@@ -116,8 +116,8 @@ func (sf *Миссии) kill3tanks() {
 // Проверяет награду оборонительного сражения
 func (сам *Миссии) сражениеЗащита() {
 	var (
-		strOut string
-		isFind bool
+		strOut  string
+		iсамind bool
 	)
 	ош := сам.сеть.Обновить()
 	if ош != nil {
@@ -128,11 +128,11 @@ func (сам *Миссии) сражениеЗащита() {
 	// <a class="simple-but border" href="?23-1.ILinkListener-missions-cc-0-c-awardLink"><span><span>Получить награду</span></span></a>
 	for _, strOut = range списМиссия {
 		if strings.Contains(strOut, `.ILinkListener-missions-cc-0-c-awardLink`) {
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind {
+	if !iсамind {
 		return
 	}
 	// <a class="simple-but border" href="?70-1.ILinkListener-missions-cc-0-c-awardLink"><span><span>Получить награду</span></span></a>
@@ -151,20 +151,20 @@ func (сам *Миссии) сражениеЗащита() {
 }
 
 // Проверяет награду за одну войну
-func (sf *Миссии) проведиВойну() {
+func (сам *Миссии) проведиВойну() {
 	var (
 		strOut      string
-		lstMissions = sf.СписПолучить()
-		isFind      bool
+		lstMissions = сам.СписПолучить()
+		iсамind     bool
 		ind         int
 	)
 	for ind, strOut = range lstMissions {
 		if strings.Contains(strOut, `Проведи одну войну<br/>`) {
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind {
+	if !iсамind {
 		return
 	}
 	// <a class="simple-but border" href="?70-1.ILinkListener-missions-cc-0-c-awardLink"><span><span>Получить награду</span></span></a>
@@ -177,12 +177,12 @@ func (sf *Миссии) проведиВойну() {
 	strLink := lstLink[1]
 	lstLink = strings.Split(strLink, `"><span><span>Получить награду</span></span></a>`)
 	strLink = "https://wartank.ru/missions/" + lstLink[0]
-	lstMissions, err := sf.сеть.Get(strLink)
+	lstMissions, err := сам.сеть.Get(strLink)
 	if err != nil {
 		// log._rintf("ERRO Миссии.battleWar(): при выполнении GET-запроса, err=\n\t%v\n", err)
 		return
 	}
-	if err := sf.СтрОбновить(lstMissions); err != nil {
+	if err := сам.СтрОбновить(lstMissions); err != nil {
 		// log._rintf("ERRO Миссии.battleWar(): при обновлении lstMissions, err=\n\t%v\n", err)
 		return
 	}
@@ -192,7 +192,7 @@ func (sf *Миссии) проведиВойну() {
 func (сам *Миссии) сражениеНаступление() {
 	var (
 		strOut      string
-		isFind      bool
+		iсамind     bool
 		ind         int
 		lstMissions = сам.СписПолучить()
 	)
@@ -205,11 +205,11 @@ func (сам *Миссии) сражениеНаступление() {
 	}
 	for ind, strOut = range lstMissions {
 		if strings.Contains(strOut, "Проведи одно наступательное сражение<br/>") {
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind {
+	if !iсамind {
 		return
 	}
 	// <a class="simple-but border" href="?70-1.ILinkListener-missions-cc-0-c-awardLink"><span><span>Получить награду</span></span></a>
@@ -234,20 +234,20 @@ func (сам *Миссии) сражениеНаступление() {
 }
 
 // Проверяет награду за схватку
-func (sf *Миссии) battleDogFyting() {
+func (сам *Миссии) battleDogFyting() {
 	var (
 		strOut      string
-		lstMissions = sf.СписПолучить()
-		isFind      bool
+		lstMissions = сам.СписПолучить()
+		iсамind     bool
 		ind         int
 	)
 	for ind, strOut = range lstMissions {
 		if strings.Contains(strOut, `Проведи одну схватку<br/>`) {
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind {
+	if !iсамind {
 		return
 	}
 	// <a class="simple-but border" href="?70-1.ILinkListener-missions-cc-0-c-awardLink"><span><span>Получить награду</span></span></a>
@@ -260,32 +260,32 @@ func (sf *Миссии) battleDogFyting() {
 	strLink := lstLink[1]
 	lstLink = strings.Split(strLink, `"><span><span>Получить награду</span></span></a>`)
 	strLink = "https://wartank.ru/missions/" + lstLink[0]
-	lstMissions, err := sf.сеть.Get(strLink)
+	lstMissions, err := сам.сеть.Get(strLink)
 	if err != nil {
 		// log._rintf("ERRO Миссии.battleDogFyting(): при выполнении GET-запроса, err=\n\t%v\n", err)
 		return
 	}
-	if err := sf.СтрОбновить(lstMissions); err != nil {
+	if err := сам.СтрОбновить(lstMissions); err != nil {
 		// log._rintf("ERRO Миссии.battleDogFyting(): при обновлении lstMissions, err=\n\t%v\n", err)
 		return
 	}
 }
 
 // Проверяет награду за ресурсы
-func (sf *Миссии) makeResource() {
+func (сам *Миссии) makeResource() {
 	var (
 		strOut      string
-		lstMissions = sf.СписПолучить()
-		isFind      bool
+		lstMissions = сам.СписПолучить()
+		iсамind     bool
 		ind         int
 	)
 	for ind, strOut = range lstMissions {
 		if strings.Contains(strOut, `Произведи на базе 10 ресурсов<br/>`) {
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind {
+	if !iсамind {
 		return
 	}
 	// <a class="simple-but border" href="?70-1.ILinkListener-missions-cc-0-c-awardLink"><span><span>Получить награду</span></span></a>
@@ -298,32 +298,32 @@ func (sf *Миссии) makeResource() {
 	strLink := lstLink[1]
 	lstLink = strings.Split(strLink, `"><span><span>Получить награду</span></span></a>`)
 	strLink = "https://wartank.ru/missions/" + lstLink[0]
-	lstMissions, err := sf.сеть.Get(strLink)
+	lstMissions, err := сам.сеть.Get(strLink)
 	if err != nil {
 		// log._rintf("ERRO Миссии.makeResource(): при выполнении GET-запроса, err=\n\t%v\n", err)
 		return
 	}
-	if err := sf.СтрОбновить(lstMissions); err != nil {
+	if err := сам.СтрОбновить(lstMissions); err != nil {
 		// log._rintf("ERRO Миссии.makeResource(): при обновлении lstMissions, err=\n\t%v\n", err)
 		return
 	}
 }
 
 // Проверяет награду за ресурсы
-func (sf *Миссии) upMan() {
+func (сам *Миссии) upMan() {
 	var (
 		strOut      string
-		lstMissions = sf.СписПолучить()
-		isFind      bool
+		lstMissions = сам.СписПолучить()
+		iсамind     bool
 		ind         int
 	)
 	for ind, strOut = range lstMissions {
 		if strings.Contains(strOut, `Прокачай экипаж на 100 опыта экипажа<br/>`) {
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind {
+	if !iсамind {
 		return
 	}
 	// <a class="simple-but border" href="?70-1.ILinkListener-missions-cc-0-c-awardLink"><span><span>Получить награду</span></span></a>
@@ -336,12 +336,12 @@ func (sf *Миссии) upMan() {
 	strLink := lstLink[1]
 	lstLink = strings.Split(strLink, `"><span><span>Получить награду</span></span></a>`)
 	strLink = "https://wartank.ru/missions/" + lstLink[0]
-	lstMissions, err := sf.сеть.Get(strLink)
+	lstMissions, err := сам.сеть.Get(strLink)
 	if err != nil {
 		// log._rintf("ERRO Миссии.upMan(): при выполнении GET-запроса, err=\n\t%v\n", err)
 		return
 	}
-	if err := sf.СтрОбновить(lstMissions); err != nil {
+	if err := сам.СтрОбновить(lstMissions); err != nil {
 		// log._rintf("ERRO Миссии.upMan(): при обновлении lstMissions, err=\n\t%v\n", err)
 		return
 	}
@@ -349,20 +349,20 @@ func (sf *Миссии) upMan() {
 }
 
 // Проверяет награду за топливо
-func (sf *Миссии) топливоДив() {
+func (сам *Миссии) топливоДив() {
 	var (
 		strOut      string
-		lstMissions = sf.СписПолучить()
-		isFind      bool
+		lstMissions = сам.СписПолучить()
+		iсамind     bool
 		ind         int
 	)
 	for ind, strOut = range lstMissions {
 		if strings.Contains(strOut, `Получи топливо в дивизии<br/>`) {
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind {
+	if !iсамind {
 		return
 	}
 	// <a class="simple-but border" href="?157-1.ILinkListener-missions-cc-0-c-awardLink"><span><span>Получить награду</span></span></a>
@@ -375,12 +375,12 @@ func (sf *Миссии) топливоДив() {
 	strLink := lstLink[1]
 	lstLink = strings.Split(strLink, `"><span><span>Получить награду</span></span></a>`)
 	strLink = "https://wartank.ru/missions/" + lstLink[0]
-	lstMissions, err := sf.сеть.Get(strLink)
+	lstMissions, err := сам.сеть.Get(strLink)
 	if err != nil {
 		// log._rintf("ERRO Миссии.makeFuel(): при выполнении GET-запроса, err=\n\t%v\n", err)
 		return
 	}
-	if err := sf.СтрОбновить(lstMissions); err != nil {
+	if err := сам.СтрОбновить(lstMissions); err != nil {
 		// log._rintf("ERRO Миссии.makeFuel(): при обновлении lstMissions, err=\n\t%v\n", err)
 		return
 	}
@@ -388,20 +388,20 @@ func (sf *Миссии) топливоДив() {
 }
 
 // Проверяет награду 5 боёв
-func (sf *Миссии) battle5Fiting() {
+func (сам *Миссии) battle5Fiting() {
 	var (
 		strOut      string
-		lstMissions = sf.СписПолучить()
-		isFind      bool
+		lstMissions = сам.СписПолучить()
+		iсамind     bool
 		ind         int
 	)
 	for ind, strOut = range lstMissions {
 		if strings.Contains(strOut, `Проведи 5 боев<br/>`) {
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind {
+	if !iсамind {
 		return
 	}
 	// <a class="simple-but border" href="?113-1.ILinkListener-missions-cc-0-c-awardLink"><span><span>Получить награду</span></span></a>
@@ -414,32 +414,32 @@ func (sf *Миссии) battle5Fiting() {
 	strLink := lstLink[1]
 	lstLink = strings.Split(strLink, `"><span><span>Получить награду</span></span></a>`)
 	strLink = "https://wartank.ru/missions/" + lstLink[0]
-	lstMissions, err := sf.сеть.Get(strLink)
+	lstMissions, err := сам.сеть.Get(strLink)
 	if err != nil {
 		// log._rintf("ERRO Миссии.battle5Fiting(): при выполнении GET-запроса, err=\n\t%v\n", err)
 		return
 	}
-	if err := sf.СтрОбновить(lstMissions); err != nil {
+	if err := сам.СтрОбновить(lstMissions); err != nil {
 		// log._rintf("ERRO Миссии.battle5Fiting(): при обновлении lstMissions, err=\n\t%v\n", err)
 		return
 	}
 }
 
 // Проверяет награду 10 боёв
-func (sf *Миссии) battle10Fiting() {
+func (сам *Миссии) battle10Fiting() {
 	var (
 		strOut      string
-		lstMissions = sf.СписПолучить()
-		isFind      bool
+		lstMissions = сам.СписПолучить()
+		iсамind     bool
 		ind         int
 	)
 	for ind, strOut = range lstMissions {
 		if strings.Contains(strOut, `Уничтожь в бою 10 танков<br/>`) {
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind {
+	if !iсамind {
 		return
 	}
 	// <a class="simple-but border" href="?113-1.ILinkListener-missions-cc-0-c-awardLink"><span><span>Получить награду</span></span></a>
@@ -452,32 +452,32 @@ func (sf *Миссии) battle10Fiting() {
 	strLink := lstLink[1]
 	lstLink = strings.Split(strLink, `"><span><span>Получить награду</span></span></a>`)
 	strLink = "https://wartank.ru/missions/" + lstLink[0]
-	lstMissions, err := sf.сеть.Get(strLink)
+	lstMissions, err := сам.сеть.Get(strLink)
 	if err != nil {
 		// log._rintf("ERRO Миссии.battle10Fiting(): при выполнении GET-запроса, err=\n\t%v\n", err)
 		return
 	}
-	if err := sf.СтрОбновить(lstMissions); err != nil {
+	if err := сам.СтрОбновить(lstMissions); err != nil {
 		// log._rintf("ERRO Миссии.battle10Fiting(): при обновлении lstMissions, err=\n\t%v\n", err)
 		return
 	}
 }
 
 // Проверяет награду за 6 побед подряд
-func (sf *Миссии) battle6win() {
+func (сам *Миссии) battle6win() {
 	var (
 		strOut      string
-		lstMissions = sf.СписПолучить()
-		isFind      bool
+		lstMissions = сам.СписПолучить()
+		iсамind     bool
 		ind         int
 	)
 	for ind, strOut = range lstMissions {
 		if strings.Contains(strOut, `Победи 6 раз подряд<br/>`) {
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind {
+	if !iсамind {
 		return
 	}
 	// <a class="simple-but border" href="?113-1.ILinkListener-missions-cc-0-c-awardLink"><span><span>Получить награду</span></span></a>
@@ -490,12 +490,12 @@ func (sf *Миссии) battle6win() {
 	strLink := lstLink[1]
 	lstLink = strings.Split(strLink, `"><span><span>Получить награду</span></span></a>`)
 	strLink = "https://wartank.ru/missions/" + lstLink[0]
-	lstMissions, err := sf.сеть.Get(strLink)
+	lstMissions, err := сам.сеть.Get(strLink)
 	if err != nil {
 		// log._rintf("ERRO Миссии.battle6win(): при выполнении GET-запроса, err=\n\t%v\n", err)
 		return
 	}
-	if err := sf.СтрОбновить(lstMissions); err != nil {
+	if err := сам.СтрОбновить(lstMissions); err != nil {
 		// log._rintf("ERRO Миссии.battle6win(): при обновлении lstMissions, err=\n\t%v\n", err)
 		return
 	}

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

@@ -23,8 +23,8 @@ func NewMissionsNet(mission types.ИМиссии) (*MissionsNet, error) {
 		return nil, fmt.Errorf("NewMissionsNet(): in create *SectionNet, err=\n\t%w", err)
 	}
 
-	sf := &MissionsNet{
+	сам := &MissionsNet{
 		СценаСеть: sectionNet,
 	}
-	return sf, nil
+	return сам, nil
 }

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

@@ -24,44 +24,44 @@ func NewNetStat(bot types.ИБот) (*NetStat, error) {
 	if bot == nil {
 		return nil, fmt.Errorf("NewNetStat(): IBot == nil")
 	}
-	sf := &NetStat{
+	сам := &NetStat{
 		server: bot.Сервер(),
 		bot:    bot,
 	}
-	return sf, nil
+	return сам, nil
 }
 
-func (sf *NetStat) Update() (err error) {
+func (сам *NetStat) Update() (err error) {
 	// _mt.Println("\n===NetStat.Update()===")
-	sf.findLevelTank()
-	if err = sf.findLevelProgress(); err != nil {
+	сам.findLevelTank()
+	if err = сам.findLevelProgress(); err != nil {
 		return fmt.Errorf("NetStat.Update(): in find level progress, err=\n\t%w", err)
 	}
-	if err = sf.findAtack(); err != nil {
+	if err = сам.findAtack(); err != nil {
 		return fmt.Errorf("NetStat.Update(): in find atack, err=\n\t%w", err)
 	}
-	if err = sf.findArmor(); err != nil {
+	if err = сам.findArmor(); err != nil {
 		return fmt.Errorf("NetStat.Update(): in find woll, err=\n\t%w", err)
 	}
-	if err = sf.findFyne(); err != nil {
+	if err = сам.findFyne(); err != nil {
 		return fmt.Errorf("NetStat.Update(): in find woll, err=\n\t%w", err)
 	}
-	if err = sf.findHard(); err != nil {
+	if err = сам.findHard(); err != nil {
 		return fmt.Errorf("NetStat.Update(): in find body, err=\n\t%w", err)
 	}
-	if err = sf.findPower(); err != nil {
+	if err = сам.findPower(); err != nil {
 		return fmt.Errorf("NetStat.Update(): in find power, err=\n\t%w", err)
 	}
-	if err = sf.findOnline(); err != nil {
+	if err = сам.findOnline(); err != nil {
 		return fmt.Errorf("NetStat.Update(): in find online, err=\n\t%w", err)
 	}
 	return nil
 }
 
 // Ищет в теле текста ангара мощность танка
-func (sf *NetStat) findPower() (err error) {
+func (сам *NetStat) findPower() (err error) {
 	// _mt.Println("\tNetStat.findPower()")
-	lstAngar := sf.bot.Ангар().СписПолучить()
+	lstAngar := сам.bot.Ангар().СписПолучить()
 	if len(lstAngar) == 0 {
 		// log._rintf("WARN NetStat.findPower(): lstAngar is empty\n")
 		return
@@ -82,16 +82,16 @@ func (sf *NetStat) findPower() (err error) {
 	if err != nil {
 		return fmt.Errorf("NetStat.findPower(): power(%v) not number, err=\n\t%w", strPower, err)
 	}
-	sf.bot.Танк().ТанкСтат().Мощь().Уст(iPower)
+	сам.bot.Танк().ТанкСтат().Мощь().Уст(iPower)
 	return nil
 }
 
 // Ищет в теле текста ангара прочность танка
-func (sf *NetStat) findHard() (err error) {
+func (сам *NetStat) findHard() (err error) {
 	var (
 		strOut   string
-		lstAngar = sf.bot.Ангар().СписПолучить()
-		isFind   bool
+		lstAngar = сам.bot.Ангар().СписПолучить()
+		iсамind  bool
 	)
 	if len(lstAngar) == 0 {
 		// log._rintf("WARN NetStat.findHard(): lstAngar пустой\n")
@@ -99,11 +99,11 @@ func (sf *NetStat) findHard() (err error) {
 	}
 	for _, strOut = range lstAngar {
 		if strings.Contains(strOut, `/images/icons/durability.png?1`) {
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind {
+	if !iсамind {
 		return
 	}
 	// Выделить прочность
@@ -115,17 +115,17 @@ func (sf *NetStat) findHard() (err error) {
 	if err != nil {
 		return fmt.Errorf("NetStat.findHard(): hard(%v) not number, err=\n\t%w", strHard, err)
 	}
-	sf.bot.Танк().ТанкСтат().Прочность().Уст(iHard)
+	сам.bot.Танк().ТанкСтат().Прочность().Уст(iHard)
 	return nil
 }
 
 // Ищет в теле текста ангара точность танка
-func (sf *NetStat) findFyne() (err error) {
+func (сам *NetStat) findFyne() (err error) {
 	// _mt.Println("\tNetStat.findFyne()")
 	var (
 		strOut   string
-		lstAngar = sf.bot.Ангар().СписПолучить()
-		isFind   bool
+		lstAngar = сам.bot.Ангар().СписПолучить()
+		iсамind  bool
 	)
 	if len(lstAngar) == 0 {
 		// log._rintf("WARN NetStat.findFyne(): lstAngar пустой\n")
@@ -133,11 +133,11 @@ func (sf *NetStat) findFyne() (err error) {
 	}
 	for _, strOut = range lstAngar {
 		if strings.Contains(strOut, `/images/icons/accuracy.png?1`) {
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind {
+	if !iсамind {
 		return nil
 	}
 	// Выделить броню
@@ -149,29 +149,29 @@ func (sf *NetStat) findFyne() (err error) {
 	if err != nil {
 		return fmt.Errorf("NetStat.findFyne(): fyne(%v) not number, err=\n\t%w", strFyne, err)
 	}
-	sf.bot.Танк().ТанкСтат().Точность().Уст(iFyne)
+	сам.bot.Танк().ТанкСтат().Точность().Уст(iFyne)
 	return nil
 }
 
 // Ищет в теле текста ангара броню танка
-func (sf *NetStat) findArmor() (err error) {
+func (сам *NetStat) findArmor() (err error) {
 	// _mt.Println("\tNetStat.findArmor()")
 
 	var (
 		strOut   string
-		lstAngar = sf.bot.Ангар().СписПолучить()
-		isFind   bool
+		lstAngar = сам.bot.Ангар().СписПолучить()
+		iсамind  bool
 	)
 	if len(lstAngar) == 0 {
 		return nil
 	}
 	for _, strOut = range lstAngar {
 		if strings.Contains(strOut, `/images/icons/armor.png?1`) {
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind {
+	if !iсамind {
 		return
 	}
 	// Выделить броню
@@ -183,14 +183,14 @@ func (sf *NetStat) findArmor() (err error) {
 	if err != nil {
 		return fmt.Errorf("NetStat.findArmor(): armor(%v) not number, err=\n\t%w", strArmor, err)
 	}
-	sf.bot.Танк().ТанкСтат().Броня().Уст(iArmor)
+	сам.bot.Танк().ТанкСтат().Броня().Уст(iArmor)
 	return nil
 }
 
 // Ищет в теле текста ангара уровень танка
-func (sf *NetStat) findLevelTank() {
+func (сам *NetStat) findLevelTank() {
 	// _mt.Println("\tNetStat.findLevelTank()")
-	lstAngar := sf.bot.Ангар().СписПолучить()
+	lstAngar := сам.bot.Ангар().СписПолучить()
 	if len(lstAngar) == 0 {
 		// log._rintf("ERRO NetStat.findLevelTank(): пустой lstAngar")
 		return
@@ -212,13 +212,13 @@ func (sf *NetStat) findLevelTank() {
 		// log._rintf("ERRO NetStat.findLevelTank(): level(%v) не число, err=\n\t%v\n", strLevel, err)
 		return
 	}
-	sf.bot.Ангар().Уровень().Уст(iLevel)
+	сам.bot.Ангар().Уровень().Уст(iLevel)
 }
 
 // Ищет в теле текста ангара прогресс уровня танка танка
-func (sf *NetStat) findLevelProgress() error {
+func (сам *NetStat) findLevelProgress() error {
 	// _mt.Println("\tNetStat.findLevelProgress()")
-	lstAngar := sf.bot.Ангар().СписПолучить()
+	lstAngar := сам.bot.Ангар().СписПолучить()
 	if len(lstAngar) == 0 {
 		// log._rintf("WARN NetStat.findLevelProgress(): lstAngar пустой\n")
 		return nil
@@ -239,24 +239,24 @@ func (sf *NetStat) findLevelProgress() error {
 	if err != nil {
 		return fmt.Errorf("NetStat.findLevelProgress(): progress(%v) not number, err=\n\t%w", strProg, err)
 	}
-	sf.bot.Ангар().Прогресс().Уст(iProg)
+	сам.bot.Ангар().Прогресс().Уст(iProg)
 	return nil
 }
 
 // Ищет в теле текста ангара силу атаки танка
-func (sf *NetStat) findAtack() (err error) {
+func (сам *NetStat) findAtack() (err error) {
 	var (
 		strOut   string
-		lstAngar = sf.bot.Ангар().СписПолучить()
-		isFind   bool
+		lstAngar = сам.bot.Ангар().СписПолучить()
+		iсамind  bool
 	)
 	for _, strOut = range lstAngar {
 		if strings.Contains(strOut, `/images/icons/attack.png?1`) {
-			isFind = true
+			iсамind = true
 			break
 		}
 	}
-	if !isFind {
+	if !iсамind {
 		return nil
 	}
 	// Выделить атаку
@@ -268,14 +268,14 @@ func (sf *NetStat) findAtack() (err error) {
 	if err != nil {
 		return fmt.Errorf("NetStat.findAtack(): atack(%v) not number, err=\n\t%w", strAtack, err)
 	}
-	sf.bot.Танк().ТанкСтат().Атака().Уст(iAtack)
+	сам.bot.Танк().ТанкСтат().Атака().Уст(iAtack)
 	return nil
 }
 
 // Ищет в теле текста ангара силу атаки танка
-func (sf *NetStat) findOnline() (err error) {
+func (сам *NetStat) findOnline() (err error) {
 	// _mt.Println("\tNetStat.findOnline()")
-	lstAngar := sf.bot.Ангар().СписПолучить()
+	lstAngar := сам.bot.Ангар().СписПолучить()
 	var strOut string
 	for _, strAtack := range lstAngar {
 		if strings.Contains(strAtack, `>Онлайн</a>: `) {
@@ -286,7 +286,7 @@ func (sf *NetStat) findOnline() (err error) {
 	// Выделить число игроков онлайн
 	lstAngar = strings.Split(strOut, `<span class="yellow1">`)
 	if len(lstAngar) <= 1 {
-		sf.server.CancelApp()
+		сам.server.CancelApp()
 		return
 	}
 	strOnline := lstAngar[1]
@@ -296,6 +296,6 @@ func (sf *NetStat) findOnline() (err error) {
 	if err != nil {
 		return fmt.Errorf("NetStat.findOnline(): online(%v) not number, err=\n\t%w", iOnline, err)
 	}
-	sf.bot.Ангар().ИгрокиОнлайн().Уст(iOnline)
+	сам.bot.Ангар().ИгрокиОнлайн().Уст(iOnline)
 	return nil
 }

server/serv_bots/warbot/tank/tank.go

@@ -22,13 +22,13 @@ func NewTank() (*Танк, error) {
 	if ош != nil {
 		return nil, fmt.Errorf("NewTank(): при создании статы, ош=\n\t%w", ош)
 	}
-	sf := &Танк{
+	сам := &Танк{
 		параметры: стата,
 	}
-	return sf, nil
+	return сам, nil
 }
 
 // ТанкСтат -- возвращает объект статистики танка
-func (sf *Танк) ТанкСтат() types.ИТанкСтат {
-	return sf.параметры
+func (сам *Танк) ТанкСтат() types.ИТанкСтат {
+	return сам.параметры
 }

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

@@ -32,22 +32,22 @@ func НовСтатПарам(имя string) (*СтатПарам, error) {
 }
 
 // Уст -- устанавливает значение параметра
-func (sf *СтатПарам) Уст(val int) {
-	sf.блок.Lock()
-	defer sf.блок.Unlock()
-	sf.знач = val
+func (сам *СтатПарам) Уст(val int) {
+	сам.блок.Lock()
+	defer сам.блок.Unlock()
+	сам.знач = val
 }
 
 // Получ -- значение хранимого параметра
-func (sf *СтатПарам) Получ() int {
-	sf.блок.RLock()
-	defer sf.блок.RUnlock()
-	return sf.знач
+func (сам *СтатПарам) Получ() int {
+	сам.блок.RLock()
+	defer сам.блок.RUnlock()
+	return сам.знач
 }
 
 // Имя -- возвращает имя хранимого параметра
-func (sf *СтатПарам) Имя() string {
-	sf.блок.RLock()
-	defer sf.блок.RUnlock()
-	return sf.имя
+func (сам *СтатПарам) Имя() string {
+	сам.блок.RLock()
+	defer сам.блок.RUnlock()
+	return сам.имя
 }

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

@@ -49,7 +49,7 @@ func NewTankStat() (*TankStat, error) {
 	if ош != nil {
 		return nil, fmt.Errorf("НовТанкСтат(): при создании статы усиления, ош=\n\t%w", ош)
 	}
-	sf := &TankStat{
+	сам := &TankStat{
 		атака:     атака,
 		точность:  точность,
 		прочность: прочность,
@@ -57,37 +57,37 @@ func NewTankStat() (*TankStat, error) {
 		power:     мощь,
 		усиление:  усиление,
 	}
-	return sf, nil
+	return сам, nil
 }
 
 // Атака -- возвращает объект силы атаки
-func (sf *TankStat) Атака() types.ИСтатПарам {
-	return sf.атака
+func (сам *TankStat) Атака() types.ИСтатПарам {
+	return сам.атака
 }
 
 // Прочность -- возвращает объект прочности танка
-func (sf *TankStat) Прочность() types.ИСтатПарам {
-	return sf.броня
+func (сам *TankStat) Прочность() types.ИСтатПарам {
+	return сам.броня
 }
 
 // Точность -- возвращает объект точности танка
-func (sf *TankStat) Точность() types.ИСтатПарам {
-	return sf.точность
+func (сам *TankStat) Точность() types.ИСтатПарам {
+	return сам.точность
 }
 
 // Броня -- возвращает объект брони танка
-func (sf *TankStat) Броня() types.ИСтатПарам {
-	return sf.прочность
+func (сам *TankStat) Броня() types.ИСтатПарам {
+	return сам.прочность
 }
 
 // Мощь -- возвращает объект мощи танка
-func (sf *TankStat) Мощь() types.ИСтатПарам {
-	return sf.power
+func (сам *TankStat) Мощь() types.ИСтатПарам {
+	return сам.power
 }
 
 // Форсаж -- возвращает объект форсированного параметра
-func (sf *TankStat) Форсаж() types.ИСтатПарам {
-	return sf.усиление
+func (сам *TankStat) Форсаж() types.ИСтатПарам {
+	return сам.усиление
 }
 
 // Форсаж -- возвращает объект форсированного параметра

server/serv_bots/warbot/warbot.go

@@ -54,12 +54,12 @@ func ЗагрузитьВарБот(сервер types.ИСервер, логи
 	if err = конфиг.Unmarshall(strData); err != nil {
 		return nil, fmt.Errorf("ЗагрузитьВарБот(): in unmarshall WarBotConfig(%q) from store, err=\n\t%w", логин, err)
 	}
-	sf, err := создатьЯдроВарБот(сервер, конфиг)
+	сам, err := создатьЯдроВарБот(сервер, конфиг)
 	if err != nil {
 		return nil, fmt.Errorf("ЗагрузитьВарБот(): in make core for bot %q, err=\n\t%w", логин, err)
 	}
-	// go sf.рестарт()
-	return sf, nil
+	// go сам.рестарт()
+	return сам, nil
 }
 
 // Каждые два часа перезапускает себя
@@ -92,14 +92,14 @@ func НовВарБот(сервер types.ИСервер, логин, паро
 		Логин_:          логин,
 		Пароль_:         пароль,
 	}
-	sf, err := создатьЯдроВарБот(сервер, config)
+	сам, err := создатьЯдроВарБот(сервер, config)
 	if err != nil {
 		return nil, fmt.Errorf("НовВарБот(): in make core bot %q, err=\n\t%w", логин, err)
 	}
-	if err := sf.сохр(); err != nil {
+	if err := сам.сохр(); err != nil {
 		return nil, fmt.Errorf("НовВарБот(): in self save to store, err=\n\t%w", err)
 	}
-	return sf, nil
+	return сам, nil
 }
 
 // Создаёт ядро бота
@@ -117,7 +117,7 @@ func создатьЯдроВарБот(серв types.ИСервер, конф
 		return nil, fmt.Errorf("NewWarBot(): при создании параметров танка, ош=\n\t%w", ош)
 	}
 	ctx, fnCancel := context.WithCancel(серв.CtxApp())
-	sf := &ВарБот{
+	сам := &ВарБот{
 		сервер:         серв,
 		store:          серв.Store(),
 		танк:           танк,
@@ -129,120 +129,120 @@ func создатьЯдроВарБот(серв types.ИСервер, конф
 	}
 	var err error
 	{ // WarBotNet
-		sf.сеть, err = warbot_net.НовВарБотСеть(sf)
+		сам.сеть, err = warbot_net.НовВарБотСеть(сам)
 		if err != nil {
 			return nil, fmt.Errorf("NewWarBot(): in make IBotNet, err=\n\t%w", err)
 		}
 	}
-	sf.ангар, err = angar.НовАнгар(sf)
+	сам.ангар, err = angar.НовАнгар(сам)
 	if err != nil {
-		return nil, fmt.Errorf("NewWarBot(): bot(%q) in make IAngar, err=\n\t%w", sf.Имя(), err)
+		return nil, fmt.Errorf("NewWarBot(): bot(%q) in make IAngar, err=\n\t%w", сам.Имя(), err)
 	}
-	if sf.конфиг.ЕслиАвтозапуск_ {
-		sf.еслиАвтозапуск.Уст()
-		sf.Пуск()
+	if сам.конфиг.ЕслиАвтозапуск_ {
+		сам.еслиАвтозапуск.Уст()
+		сам.Пуск()
 	}
-	return sf, nil
+	return сам, nil
 }
 
 // Сервер -- возвращает ссылку на объект сервера
-func (sf *ВарБот) Сервер() types.ИСервер {
-	return sf.сервер
+func (сам *ВарБот) Сервер() types.ИСервер {
+	return сам.сервер
 }
 
 // ЕслиПуск -- возвращает признак, что бот подключен
-func (sf *ВарБот) ЕслиПуск() bool {
-	return sf.еслиРаботает.Получ()
+func (сам *ВарБот) ЕслиПуск() bool {
+	return сам.еслиРаботает.Получ()
 }
 
 // Имя -- возвращает имя бота
-func (sf *ВарБот) Имя() string {
-	return sf.конфиг.Логин()
+func (сам *ВарБот) Имя() string {
+	return сам.конфиг.Логин()
 }
 
 // Пароль -- возвращает пароль бота
-func (sf *ВарБот) Пароль() string {
-	return sf.конфиг.Пароль_
+func (сам *ВарБот) Пароль() string {
+	return сам.конфиг.Пароль_
 }
 
 // Пуск -- запускает бот в работу
-func (sf *ВарБот) Пуск() (err error) {
-	if sf.еслиРаботает.Получ() {
+func (сам *ВарБот) Пуск() (err error) {
+	if сам.еслиРаботает.Получ() {
 		return nil
 	}
-	if err := sf.ангар.Пуск(); err != nil {
-		return fmt.Errorf("WarBot.Run(): bot(%q) in run angar, err=\n\t%w", sf.Имя(), err)
+	if err := сам.ангар.Пуск(); err != nil {
+		return fmt.Errorf("WarBot.Run(): bot(%q) in run angar, err=\n\t%w", сам.Имя(), err)
 	}
-	sf.еслиРаботает.Уст()
+	сам.еслиРаботает.Уст()
 	return nil
 }
 
 // Error -- возвращает финальную ошибку работы, если была
-func (sf *ВарБот) Error() error {
-	return sf.errFinal
+func (сам *ВарБот) Error() error {
+	return сам.errFinal
 }
 
 // Ангар -- возвращает ангар игры
-func (sf *ВарБот) Ангар() types.ИАнгар {
-	return sf.ангар
+func (сам *ВарБот) Ангар() types.ИАнгар {
+	return сам.ангар
 }
 
 // Танк -- возвращает объект танка
-func (sf *ВарБот) Танк() types.ИТанк {
-	return sf.танк
+func (сам *ВарБот) Танк() types.ИТанк {
+	return сам.танк
 }
 
 // Сеть -- возвращает ссылку на свой сетевой клиент
-func (sf *ВарБот) Сеть() types.ИБотСеть {
-	return sf.сеть
+func (сам *ВарБот) Сеть() types.ИБотСеть {
+	return сам.сеть
 }
 
 // АвтоИграЕсли -- возвращает признак автоматичского запуска бота
-func (sf *ВарБот) АвтоИграЕсли() bool {
-	return sf.еслиАвтозапуск.Получ()
+func (сам *ВарБот) АвтоИграЕсли() bool {
+	return сам.еслиАвтозапуск.Получ()
 }
 
 // АвтоИграУст -- устанавливает признак автоматического запуска бота
-func (sf *ВарБот) АвтоИграУст() {
+func (сам *ВарБот) АвтоИграУст() {
 	log.Printf("WarBot.SetAutoGame()")
-	sf.еслиАвтозапуск.Уст()
-	sf.конфиг.ЕслиАвтозапуск_ = true
-	sf.saveConfig()
+	сам.еслиАвтозапуск.Уст()
+	сам.конфиг.ЕслиАвтозапуск_ = true
+	сам.saveConfig()
 }
 
 // АвтоИграСброс -- сбрасывает признак автоматического запуска бота
-func (sf *ВарБот) АвтоИграСброс() {
+func (сам *ВарБот) АвтоИграСброс() {
 	log.Printf("WarBot.ResetAutoGame()")
-	sf.еслиАвтозапуск.Уст()
-	sf.конфиг.ЕслиАвтозапуск_ = false
-	sf.saveConfig()
+	сам.еслиАвтозапуск.Уст()
+	сам.конфиг.ЕслиАвтозапуск_ = false
+	сам.saveConfig()
 }
 
 // Сохраняет конфиг бота
-func (sf *ВарБот) saveConfig() {
+func (сам *ВарБот) saveConfig() {
 	log.Printf("WarBot.saveConfig()")
-	strConf := sf.конфиг.Marshall()
-	err := sf.store.Put("/bots/"+sf.Имя(), strConf)
+	strConf := сам.конфиг.Marshall()
+	err := сам.store.Put("/bots/"+сам.Имя(), strConf)
 	if err != nil {
 		log.Printf("WarBot.saveConfig(): err=\n\t%v\n", err)
 	}
 }
 
 // Кнт -- возвращает контекст бота
-func (sf *ВарБот) Кнт() context.Context {
-	return sf.кнт
+func (сам *ВарБот) Кнт() context.Context {
+	return сам.кнт
 }
 
 // Закончить -- отменяет контекст бота
-func (sf *ВарБот) Закончить() {
-	sf.фтОтмена()
+func (сам *ВарБот) Закончить() {
+	сам.фтОтмена()
 }
 
 // Сохраняет себя в базу
-func (sf *ВарБот) сохр() error {
-	err := sf.store.Put("/bots/"+sf.Имя(), sf.конфиг.Marshall())
+func (сам *ВарБот) сохр() error {
+	err := сам.store.Put("/bots/"+сам.Имя(), сам.конфиг.Marshall())
 	if err != nil {
-		return fmt.Errorf("WarBot.save(): in self save to store bot(%q), err=\n\t%w", sf.Имя(), err)
+		return fmt.Errorf("WarBot.save(): in self save to store bot(%q), err=\n\t%w", сам.Имя(), err)
 	}
 	return nil
 }

server/serv_bots/warbot/warbot_config/warbot_config.go

@@ -16,14 +16,14 @@ type ВарБотКонфиг struct {
 }
 
 // Marshall -- сериализует конфиг в JSON
-func (sf *ВарБотКонфиг) Marshall() string {
-	binData, _ := json.Marshal(sf)
+func (сам *ВарБотКонфиг) Marshall() string {
+	binData, _ := json.Marshal(сам)
 	return string(binData)
 }
 
 // Unmarshall -- десериализует себя из байтового потока
-func (sf *ВарБотКонфиг) Unmarshall(strData string) error {
-	err := json.Unmarshal([]byte(strData), sf)
+func (сам *ВарБотКонфиг) Unmarshall(strData string) error {
+	err := json.Unmarshal([]byte(strData), сам)
 	if err != nil {
 		return fmt.Errorf("WarBotConfig.Unmarshall(): err=\n\t%w", err)
 	}

server/serv_bots/warbot/warbot_net/bot_cookie/bot_cookie.go

@@ -22,43 +22,43 @@ func NewBotCookie() BotCookie {
 }
 
 // Уст -- устанавливает кукисы
-func (sf *BotCookie) Уст(cook []*http.Cookie) error {
-	sf.block.Lock()
-	defer sf.block.Unlock()
+func (сам *BotCookie) Уст(cook []*http.Cookie) error {
+	сам.block.Lock()
+	defer сам.block.Unlock()
 	if cook == nil {
 		return fmt.Errorf("NetCookie.Уст(): cookie is nil")
 	}
-	sf.cookie = cook
+	сам.cookie = cook
 	cookie := http.Cookie{
 		Name:  "JSESSIONID",
-		Value: sf.cookie[0].Value,
-		Raw:   "JSESSIONID=" + sf.cookie[0].Value + "; _ym_uid=1642083867571238834; _ym_d=1642083867; _ym_isad=2; _ym_visorc=w",
+		Value: сам.cookie[0].Value,
+		Raw:   "JSESSIONID=" + сам.cookie[0].Value + "; _ym_uid=1642083867571238834; _ym_d=1642083867; _ym_isad=2; _ym_visorc=w",
 	}
-	cookie1 := sf.cookie[:0]
-	sf.cookie = cookie1
-	sf.cookie = append(sf.cookie, &cookie)
+	cookie1 := сам.cookie[:0]
+	сам.cookie = cookie1
+	сам.cookie = append(сам.cookie, &cookie)
 
 	cookie = http.Cookie{
 		Name:  "_ym_d",
 		Value: "1642083867",
 	}
-	sf.cookie = append(sf.cookie, &cookie)
+	сам.cookie = append(сам.cookie, &cookie)
 
 	cookie = http.Cookie{
 		Name:  "_ym_isad",
 		Value: "2",
 	}
-	sf.cookie = append(sf.cookie, &cookie)
+	сам.cookie = append(сам.cookie, &cookie)
 
 	cookie = http.Cookie{
 		Name:  "_ym_visorc",
 		Value: "w",
 	}
-	sf.cookie = append(sf.cookie, &cookie)
+	сам.cookie = append(сам.cookie, &cookie)
 	return nil
 }
 
 // Получ -- возвращает хранимые кукисы
-func (sf *BotCookie) Получ() []*http.Cookie {
-	return sf.cookie
+func (сам *BotCookie) Получ() []*http.Cookie {
+	return сам.cookie
 }

server/serv_bots/warbot/warbot_net/bot_net_login/bot_net_login.go

@@ -26,15 +26,15 @@ func НовБотСетьЛогин(ботСеть types.ИБотСеть) (Бо
 		}
 	}
 
-	sf := БотСетьЛогин{
+	сам := БотСетьЛогин{
 		сеть:   ботСеть,
 		клиент: ботСеть.Коннект(),
 		куки:   ботСеть.Куки(),
 	}
-	if err := sf.подключить(); err != nil {
+	if err := сам.подключить(); err != nil {
 		return БотСетьЛогин{}, fmt.Errorf("НовБотСетьЛогин() in connect to server, err=\n\t%w", err)
 	}
-	return sf, nil
+	return сам, nil
 }
 
 // Вызывается один раз
@@ -122,13 +122,13 @@ func (сам *БотСетьЛогин) получСтрЛогин(linkBegin str
 		return "", fmt.Errorf("БотСетьЛогин.получСтрЛогин(): in mske GET-request for send login page, err=\n\t%w", ош)
 	}
 	defer ответ.Body.Close()
-	// sf.cookie = resp.Cookies()
+	// сам.cookie = resp.Cookies()
 	данные, ош := io.ReadAll(ответ.Body)
 	if ош != nil {
 		return "", fmt.Errorf("БотСетьЛогин.получСтрЛогин(): in read body response, err=\n\t%w", ош)
 	}
 	стрТелоЛогин := string(данные)
-	// sf.app.AddLog(fmt.Sprintf("БотСетьЛогин.получСтрЛогин(): page_login=\n%v\n\n", strBodyLogin))
+	// сам.app.AddLog(fmt.Sprintf("БотСетьЛогин.получСтрЛогин(): page_login=\n%v\n\n", strBodyLogin))
 	return стрТелоЛогин, nil
 }
 

server/serv_bots/warbot/warbot_net/warbot_net.go

@@ -76,16 +76,16 @@ func (сам *ВарБотСеть) ЕслиОнлайн() *safe_bool.Безоп
 }
 
 // КлиентСеть -- возвращает исполнитель запросов
-func (sf *ВарБотСеть) КлиентСеть() types.ИСетьКлиент {
-	return sf.сеть
+func (сам *ВарБотСеть) КлиентСеть() types.ИСетьКлиент {
+	return сам.сеть
 }
 
 // Коннект -- возвращает HTTP-коннект
-func (sf *ВарБотСеть) Коннект() *http.Client {
-	return sf.сокет.Клиент()
+func (сам *ВарБотСеть) Коннект() *http.Client {
+	return сам.сокет.Клиент()
 }
 
 // Куки -- возвращает куки для HTTP-коннект
-func (sf *ВарБотСеть) Куки() types.ИБотКуки {
-	return sf.сокет.Куки()
+func (сам *ВарБотСеть) Куки() types.ИБотКуки {
+	return сам.сокет.Куки()
 }

server/serv_web/serv_web.go

@@ -8,10 +8,11 @@ import (
 	"time"
 
 	"github.com/gofiber/fiber/v2"
-	// "github.com/gofiber/fiber/v2/middleware/compress"
-	// "github.com/gofiber/template/html/v2"
+	"github.com/gofiber/fiber/v2/middleware/compress"
+	"github.com/gofiber/template/html/v2"
 
 	"wartank/pkg/types"
+	"wartank/server/serv_web/web_gui"
 )
 
 type СервВеб struct {
@@ -30,7 +31,7 @@ func НовСервВеб(серв types.ИСервер) (*СервВеб, error
 	if стенд == "prod" {
 		порт = "18060"
 	}
-	// engine := html.New("./web/tmpl", ".tmpl.html")
+	engine := html.New("./web/tmpl", ".tmpl.html")
 
 	конф := fiber.Config{
 		// Prefork:                      false,
@@ -42,7 +43,7 @@ func НовСервВеб(серв types.ИСервер) (*СервВеб, error
 		//ETag:                         false,
 		BodyLimit:   10_000_000,
 		Concurrency: 50,
-		// Views:       engine,
+		Views:       engine,
 		//ViewsLayout:                  "",
 		//PassLocalsToViews:            false,
 		ReadTimeout:     15 * time.Second,
@@ -90,24 +91,39 @@ func НовСервВеб(серв types.ИСервер) (*СервВеб, error
 		роутер: *fiber.New(конф),
 		порт:   порт,
 	}
-	// compresConfig := compress.Config{
-	// 	Level: compress.LevelBestCompression,
-	// }
-	// сам.роутер.Use(compress.New(compresConfig))
-	// сам.роутер.Static("/static", "./web/static", fiber.Static{
-	// 	Compress:      true,
-	// 	ByteRange:     true,
-	// 	Browse:        true,
-	// 	Index:         "index.html",
-	// 	CacheDuration: 30 * time.Second,
-	// 	MaxAge:        3600,
-	// })
+	compresConfig := compress.Config{
+		Level: compress.LevelBestCompression,
+	}
+	сам.роутер.Use(compress.New(compresConfig))
+	сам.роутер.Static("/static", "./web/static", fiber.Static{
+		Compress:      true,
+		ByteRange:     true,
+		Browse:        true,
+		Index:         "index.html",
+		CacheDuration: 30 * time.Second,
+		MaxAge:        3600,
+	})
 	сам.роутер.Get("/list_bot/get", сам.гетСписБот)
 	сам.роутер.Post("/list_bot/add", сам.постБотНов)
 	сам.роутер.Post("bot/stat", сам.постБотСтат)
+
+	_, ош := web_gui.НовВебГуи(сам)
+	if ош != nil {
+		return nil, fmt.Errorf("НовСерВеб(): при создании веб-гуи, ош=\n\t%w", ош)
+	}
 	return сам, nil
 }
 
+// Файбер -- возвращает файбер
+func (сам *СервВеб) Файбер() *fiber.App {
+	return &сам.роутер
+}
+
+// Сервер -- возвращает сервер
+func (сам *СервВеб) Сервер() types.ИСервер {
+	return сам.серв
+}
+
 // Пуск -- запускае веб-сервер в работу
 func (сам *СервВеб) Пуск() {
 	фнПуск := func() {

server/serv_web/web_gui/web_gui.go

@@ -0,0 +1,36 @@
+// package web_gui -- веб-сервер для графики
+package web_gui
+
+import (
+	"fmt"
+
+	"wartank/pkg/types"
+
+	"github.com/gofiber/fiber/v2"
+)
+
+// ВебГип -- веб-сервер для графики
+type ВебГуи struct {
+	серв   types.ИСервер
+	файбер *fiber.App
+}
+
+// НовВебГуи -- возвращает новый веб-сервер для графики
+func НовВебГуи(вебСервер types.ИВебСервер) (*ВебГуи, error) {
+	if вебСервер == nil {
+		return nil, fmt.Errorf("НовВебГуи(): ИВебСервер==nil")
+	}
+	сам := &ВебГуи{
+		серв:   вебСервер.Сервер(),
+		файбер: вебСервер.Файбер(),
+	}
+	сам.файбер.Get("/", сам.индекс)
+	return сам, nil
+}
+
+// Возвращает индексную страницу
+func (сам *ВебГуи) индекс(кнт *fiber.Ctx) error {
+	return кнт.Render("index", fiber.Map{
+		"Title": "WarTank",
+	})
+}

server/server.go

@@ -37,7 +37,7 @@ func НовСервер() (*Сервер, error) {
 		return nil, fmt.Errorf("НовСервер(): in create ServBots, err=\n\t%w", ош)
 	}
 	/*
-		sf.gui, err = serv_desktop.НовСерверДесктоп(sf)
+		сам.gui, err = serv_desktop.НовСерверДесктоп(сам)
 		if err != nil {
 			return nil, fmt.Errorf("НовСервер(): in make Gui, err=\n\t%w", err)
 		}
@@ -50,8 +50,8 @@ func НовСервер() (*Сервер, error) {
 }
 
 // Store -- возвращает хранилище
-func (sf *Сервер) Store() types.IStore {
-	return sf.хранилище
+func (сам *Сервер) Store() types.IStore {
+	return сам.хранилище
 }
 
 // Run -- запускает сервер бота в работу
@@ -62,11 +62,11 @@ func (сам *Сервер) Run() error {
 }
 
 // ServBots -- возвращает словарь ботов
-func (sf *Сервер) ServBots() types.ИБотоФерма {
-	return sf.ботоФерма
+func (сам *Сервер) ServBots() types.ИБотоФерма {
+	return сам.ботоФерма
 }
 
 // Gui -- возвращает графику фермы-ботов
-func (sf *Сервер) Gui() types.ИГуи {
-	return nil // sf.gui
+func (сам *Сервер) Gui() types.ИГуи {
+	return nil // сам.gui
 }