Dota programming. Details of creating a bot for Dot 2

What programming language is DOTA 2 written in? Dota 2 is running on Source 2 engine by Valve Corporation. Source 2 itself is written solely in C and C++
(in Source there was also some code written in pure MASM x86; maybe it was removed in Source 2).

Change in rating TrueSkill
(similar to Elo rating
for chess) of our bot over time, calculated by simulating games between bots.

The project developed as follows. 15% of players are below 1.5K on a scale of MMR
; 58% of players have it below 3K; 99.99% of players are below 7.5K.

• May 1: first results
reinforcement learning
in a simple Dota environment where Drow Ranger learns to fight a hard-coded Earthshaker.

• May 8: tester with MMR
at 1.5K says his scores are improving faster than the bot.

• Early June: won against tester with MMR 1.5K

• June 30: Won most of the games against a tester with MMR 3000.

• July 8: won by a small margin for the first time
from a semi-professional tester with an MMR of 7.5K.

• August 7: won Blitz
(6.2K, former pro) 3-0, Pajkatt
(8.5K, professional) 2-1, and CC&C
(8.9K, pro) 3-0. They all agreed that SumaiL would figure out how to beat him.

• August 9: Defeated Arteezy (10K, pro, one of the best players) 10-0. He said that SumaiL could handle this bot.

• August 10: Defeated SumaiL (8.3K, Pro, MVP 1v1) 6-0. The player stated that the bot cannot be defeated. Played with the version of the bot from August 9, won 2-1.

• August 11: Defeated Dendi (7.3K, Pro, Former World Champion) 2-0. 60% more wins than the August 10th version.

Game against SumaiL

  
 
 

 
 


 
 


 
   # talk to GC 




  

  

 
 

 
   # call do_stuff just one time 

 
  

  

   # optional arguments 

  

Hello, this article will cover legal
ways to gain an advantage over the enemy using simple tools like NodeJS, Electron and React, while bypassing the ban. I was inspired to experiment by another article Visualization of Roshan’s respawn time
and the desire to automate part of the routine. It is worth noting that now tools that do not modify the game in any dishonest way will be considered — all APIs are open, the data is obtained in an honest way, there is no interference in the game process. Under the cut there will be several pictures and some code.

All source code is located on Github
, you can get acquainted with it, like it, fork it, suggest changes. I wrote it with the left heel of my right foot, right during the game, so please do not swear too much for the style.

To be honest, I haven’t come up with anything new, everything has already been invented before me, and there are even ready-made applications that can do the same thing.

Further knowledge can be used both in the name of good — making tools for analytics studios, eSports, Twitch streams, team training, etc., and in the name of evil — writing cheats, the choice is yours.

Disclaimer: The author is not responsible for your application of the knowledge gained in this article or damage resulting from their use. All information here is provided for educational purposes only. Especially for MOBA companies to help them fight cheaters. And, of course, the author of the article is a botanist, a cheater and always has been.

As a result, the created tools can:

• Game time tracking

• Play sounds before important events start

• Display current gold values ​​(GPM)

• Display hero stats from open source OpenDota.com

• Track Roshan respawn time

• Gather data on favorite enemy heroes

What other improvements can be made:

• Display enemy average history

• Add a retrospective analysis of the game at the end of it

• Add more sound/visual notifications

• Make it possible to track «ultimates»

• Add more visual data while watching esports games

• Add detailed guides right during the game

How it all began

Dota 2 suddenly has GSI ( Game State Integration
), which was invented to integrate third-party applications / overlays (image overlay on top of the game) and synchronize these same overlays with the game in real time. This suggests that you can get the state of the game and then do something with it. There is a ready-made solution for integration with NodeJS in the form of a library
. For the GSI server to work, first of all, you need to create a configuration file in «Steam\steamapps\common\dota 2 beta\game\dota\cfg», this file contains settings, for example, the following:

 "dota2-gsi Configuration"
{
    "uri"               "http://localhost:3001/"
    "timeout"           "5.0"
    "buffer"            "0.1"
    "throttle"          "0.1"
    "heartbeat"         "30.0"
    "data"
    {
        "buildings"     "1"
        "provider"      "1"
        "map"           "1"
        "player"        "1"
        "hero"          "1"
        "abilities"     "1"
        "items"         "1"
        "draft"         "1"
        "wearables"     "1"
    }
}
  

After restarting the game, the new settings are pulled up and the GSI server is launched, which will send data via HTTP to localhost:3001, on which the NodeJS server will rise
:

 var server = app.listen(3001, () => {
  console.log("Dota 2 GSI listening on port " + server.address().port);
});
  

Actually, after the listener code is launched
, which is just borrowed from a third-party NodeJS library

The server for receiving data about the game world is ready.

Data that does not provide an advantage

During a ranked match in Dota 2, GSI gives truncated data, useful data is available

• Elapsed number of seconds since game start

• Game time in seconds

 {
    "ip": "::ffff:127.0.0.1",
    "gamestate": {
        "buildings": {
            "radiant": {
                "dota_goodguys_tower1_top": {
                    "health": 1800,
                    "max_health": 1800
                },
                "dota_goodguys_tower2_top": {
                    "health": 2500,
                    "max_health": 2500
                },
                "dota_goodguys_tower3_top": {
                    "health": 2500,
                    "max_health": 2500
                },
                "dota_goodguys_tower1_mid": {
                    "health": 1800,
                    "max_health": 1800
                },
                "dota_goodguys_tower2_mid": {
                    "health": 2500,
                    "max_health": 2500
                },
                "dota_goodguys_tower3_mid": {
                    "health": 2500,
                    "max_health": 2500
                },
                "dota_goodguys_tower1_bot": {
                    "health": 1800,
                    "max_health": 1800
                },
                "dota_goodguys_tower2_bot": {
                    "health": 2500,
                    "max_health": 2500
                },
                "dota_goodguys_tower3_bot": {
                    "health": 2500,
                    "max_health": 2500
                },
                "dota_goodguys_tower4_top": {
                    "health": 2600,
                    "max_health": 2600
                },
                "dota_goodguys_tower4_bot": {
                    "health": 2600,
                    "max_health": 2600
                },
                "good_rax_melee_top": { "health": 2200, "max_health": 2200 },
                "good_rax_range_top": { "health": 1300, "max_health": 1300 },
                "good_rax_melee_mid": { "health": 2200, "max_health": 2200 },
                "good_rax_range_mid": { "health": 1300, "max_health": 1300 },
                "good_rax_melee_bot": { "health": 2200, "max_health": 2200 },
                "good_rax_range_bot": { "health": 1300, "max_health": 1300 },
                "dota_goodguys_fort": { "health": 4500, "max_health": 4500 }
            }
        },
        "provider": {
            "name": "Dota 2",
            "appid": 570,
            "version": 47,
            "timestamp": 1613780229
        },
        "map": {
            "name": "dota",
            "matchid": "0",
            "game_time": 2,
            "clock_time": 1,
            "daytime": true,
            "nightstalker_night": false,
            "game_state": "DOTA_GAMERULES_STATE_GAME_IN_PROGRESS",
            "paused": false,
            "win_team": "none",
            "customgamename": "C:\\Program Files (x86)\\Steam\\steamapps\\common\\dota 2 beta\\game\\dota_addons\\hero_demo",
            "ward_purchase_cooldown": 0
        },
        "player": {
            "steamid": "76561198282999022",
            "name": "D1rty F0x",
            "activity": "playing",
            "kills": 0,
            "deaths": 0,
            "assists": 0,
            "last_hits": 0,
            "denies": 0,
            "kill_streak": 0,
            "commands_issued": 0,
            "kill_list": {},
            "team_name": "radiant",
            "gold": 99999,
            "gold_reliable": 0,
            "gold_unreliable": 99999,
            "gold_from_hero_kills": 0,
            "gold_from_creep_kills": 0,
            "gold_from_income": 2,
            "gold_from_shared": 0,
            "gpm": 3913086,
            "xpm": 0
        },
        "hero": {
            "xpos": -6700,
            "ypos": -6700,
            "id": 6,
            "name": "npc_dota_hero_drow_ranger",
            "level": 1,
            "alive": true,
            "respawn_seconds": 0,
            "buyback_cost": 8540,
            "buyback_cooldown": 0,
            "health": 560,
            "max_health": 560,
            "health_percent": 100,
            "mana": 255,
            "max_mana": 255,
            "mana_percent": 100,
            "silenced": false,
            "stunned": false,
            "disarmed": false,
            "magicimmune": false,
            "hexed": false,
            "muted": false,
            "break": false,
            "smoked": false,
            "has_debuff": false,
            "talent_1": false,
            "talent_2": false,
            "talent_3": false,
            "talent_4": false,
            "talent_5": false,
            "talent_6": false,
            "talent_7": false,
            "talent_8": false
        },
        "abilities": {
            "ability0": {
                "name": "drow_ranger_frost_arrows",
                "level": 0,
                "can_cast": false,
                "passive": false,
                "ability_active": true,
                "cooldown": 0,
                "ultimate": false
            },
            "ability1": {
                "name": "drow_ranger_wave_of_silence",
                "level": 0,
                "can_cast": false,
                "passive": false,
                "ability_active": true,
                "cooldown": 0,
                "ultimate": false
            },
            "ability2": {
                "name": "drow_ranger_multishot",
                "level": 0,
                "can_cast": false,
                "passive": false,
                "ability_active": true,
                "cooldown": 0,
                "ultimate": false
            },
            "ability3": {
                "name": "drow_ranger_marksmanship",
                "level": 0,
                "can_cast": false,
                "passive": true,
                "ability_active": true,
                "cooldown": 0,
                "ultimate": true
            }
        },
        "items": {
            "slot0": { "name": "empty" },
            "slot1": { "name": "empty" },
            "slot2": { "name": "empty" },
            "slot3": { "name": "empty" },
            "slot4": { "name": "empty" },
            "slot5": { "name": "empty" },
            "slot6": { "name": "empty" },
            "slot7": { "name": "empty" },
            "slot8": { "name": "empty" },
            "stash0": { "name": "empty" },
            "stash1": { "name": "empty" },
            "stash2": { "name": "empty" },
            "stash3": { "name": "empty" },
            "stash4": { "name": "empty" },
            "stash5": { "name": "empty" }
        },
        "draft": {},
        "wearables": {
            "wearable0": 77,
            "wearable1": 76,
            "wearable2": 5841,
            "wearable3": 80,
            "wearable4": 78,
            "wearable5": 267,
            "wearable6": 79,
            "wearable7": 8632,
            "wearable8": 737,
            "wearable9": 14912
        },
        "previously": { "player": { "gpm": 5000054 } }
    }
}

  

If you watch a replay or someone else’s game, then much more information is available — all of it is described here
. Well, the most important information is already available to us — GPM, game time, hero Id.

After receiving the information, we must do something with it, for example, draw or warn about the moment in the game.

UI, Alerts, Electron

For the UI, it was decided to use Electron and run React inside this electron. The idea is to draw the Electron application on top of the game (overlay). Overlay source can be found here
, let’s dwell on it a little — there are a couple of features.

First you need to set up a window in which everything will be displayed:

 const win = new BrowserWindow({
  width: 210,
  height: 200,
  // Окно должно без рамки
  frame: false,
  // Окно может быть прозрачным
  transparent: true,
  webPreferences: {
    // Фикс багов связанных с импортами React
    nodeIntegration: true,
  },
});
// Окно должно всегда быть поверх остальных
win.setAlwaysOnTop(true, "screen-saver");
  

At first, I couldn’t display something over Dota until I came across a setting in the machine_convars.vcfg (Dota 2) file called «dota_mouse_window_lock», which needs to be set to «0», but in the game itself (either in the same configuration files) set the display mode in a frameless window.

The UI was written using React, so it was decided to download it directly from the development dev server (yes, I’m lazy):

 function loadWindow() {
  setTimeout(() => {
    win.loadURL("http://localhost:3000").catch(loadWindow);
  }, 3000);
}
loadWindow();
  

If the dev server did not have time to boot, then we will try again in 3 seconds, that’s what setTimeout is for.

That’s it, we’re done with the overlay, now the UI part.

My favorite stack was chosen in UI: TS, CRA (Styled was used only for one/two classes — there’s not much to draw). After GSI Dota2 has sent the data to the express server, it needs to be transferred to the front. Write a simple GET handle to return data
. Then a hook is written at the front, which requests this data once a second, and then they go immediately to all other hooks. That is, all hooks are launched every second in the application — this is an important fact, because sometimes you need to store the launch time of the hook so that you don’t accidentally launch it several times (if you don’t, then you will have at best two notifications in a row, at worst an explosion from alerts). Data acquisition logic:

 import { State } from "../state/state";
import { useState } from "react";
import { useInterval } from "./useInterval";

const SERVER_URL = "http://localhost:3001/time";
const UPDATE_FREQUENTLY = Number(process.env.REACT_APP_SERVER_UPDATE_FREQUENTLY);

export function useServerState(): State {
  const [state, setState] = useState<State>({});

  useInterval(async () => {
    try {
      const data = await (await fetch(SERVER_URL)).json();
      setState(data);
    } catch {}
  }, UPDATE_FREQUENTLY);

  return state;
}
  

Now that we have all the data on the front, we can write a hook for sound alerts
that it’s time to go (30 seconds before the start notifies) to pick up the runes of wealth that appear at every minute multiple of five (5, 10, 15, 20 minutes):

 export function useBountyRunes(state: State) {
  const clockTime = clockTimeSelector(state);
  const [play] = useSound(bountiesMp3, { volume: 0.25 });
  const [lastIntervalPlay, setLastIntervalPlay] = useState<number>(-1);

  useEffect(() => {
    // Проверка, что  время пришло корректное
    if (!clockTime || isNegative(clockTime)) {
      return;
    }

    // Проверка кратности минуты на 4,5 и проверка от двойного оповещения
    if (isNeedToPlay(clockTime, lastIntervalPlay)) {
      // Проигрываем звук
      play();
      // Записываем когда последний раз было оповещение
      setLastIntervalPlay(getInterval(clockTime + ALARM_BEFORE));
    }
  }, [clockTime, lastIntervalPlay, play]);
}
  

The record about the last playback (setLastIntervalPlay) is needed in order not to repeat the notification accidentally twice.

And now there is one advantage in the game, maybe it is insignificant, but it seems to me that it manages the team’s attention quite well. Well, you can go further and make the same roshan respawn button
, as from the last article:

 export function useRoshanSpawn(state: State) {
  const currentGameTime = gameTimeSelector(state) || 0;
  const [play] = useSound(roshanRespawnMp3, { volume: 0.25 });
  const [roshanStopwatch, setRoshanStopwatch] = useState<RoshanStopwatch>({
    isActive: false,
    time: 0,
    isPlayedSound: false,
  });

  // Фиксация смерти роши
  function handleDead() {
    setRoshanStopwatch({
      time: currentGameTime,
      isActive: true,
      isPlayedSound: false,
    });
  }

  // Сброс таймера
  function handleReset() {
    setRoshanStopwatch({
      time: 0,
      isActive: false,
      isPlayedSound: false,
    });
  }

  // Проверяем роша жив, жив/мёртв, и сколько времени прошло с момента смерти
  const isDead = roshanIsDead(roshanStopwatch, currentGameTime);
  const isDeadOrLive = schrodingerRoshan(roshanStopwatch, currentGameTime);
  const timeToSpawn = roshanTimeDeadSelector(roshanStopwatch, currentGameTime);

  useEffect(() => {
    // Оповещаем звуком за 30 секунд до возможного возрождения
    if (needToPlaySound(roshanStopwatch, currentGameTime)) {
      play();
      setRoshanStopwatch({
        ...roshanStopwatch,
        isPlayedSound: true,
      });
    }
  }, [roshanStopwatch, currentGameTime, setRoshanStopwatch]);

  return { handleDead, handleReset, isDead, isDeadOrLive, timeToSpawn };
}
  

Roshan is a little more complicated than runes — it can respawn in the interval from 9 to 12 minutes. That is, it has states:

• Exactly dead (up to 9 minutes have passed since death)

• He is alive or dead (9 to 12 minutes have passed since death)

• He is definitely alive (more than 12 minutes have passed since his death or this is the beginning of the game)

Therefore, the timer has three visual states:

• Button — to start the timer

• The timer ticks and reports that Rosha is definitely dead

• The timer is ticking and tells you that Rosha may be alive or dead

And one sound notification: Roshan will be in the Schrödinger state in 30 seconds (that is, both alive and dead at the same time — you won’t know until you check). It is also possible to reset the timer, because if we checked and found out that he is alive, then the timer is no longer needed, but a button is needed to inform about the new death of Roshan. Of the minuses — sometimes you forget to start the timer, it would be great to automate this in the future too.

Enrich data

There is also information about what hero we play, so let the client request benchmarks from the site OpenDota.com
and display them to make it clear how far we are behind the rhythm of the game. I took the 99% percentile, that is, I’m wondering with what indicators the 1% of the best games play on this or that hero.

All logic is described in the hook useBenchmark
:

 export function useBenchmarks(state: State): State {
  const [localState, setLocalState] = useState<Benchmarks>();

  const updateBenchmarksForHero = useCallback(
    async function (id: number) {
      try {
        // Запросили данные по герою
        const response = await fetch(`${BENCHMARKS_URL}?hero_id=${id}`);
        const benchmarks = (await response.json()) as Benchmarks;

        // Сохранили бенчмарк
        setLocalState(benchmarks);
      } catch (error) {
        setLocalState({
          error,
        });
      }
    },
    [setLocalState]
  );

  useEffect(() => {
    const heroId = heroIdSelector(state);
    const benchmarksHeroId = localState?.hero_id;

    // Запрашиваем бенчмарк, при появлении информации о герое
    if (heroId && heroId !== benchmarksHeroId && !localState?.error) {
      updateBenchmarksForHero(heroId);
    }
  }, [state, localState, updateBenchmarksForHero]);
  
  // Возвращаем данные о бенчмарке
  return { ...state, benchmarks: localState };
}
  

Find out the player’s preferences

It would be great to get information about which heroes the opponent is most likely to play in order to ban, take away, counter them from him. To do this, read memory
game file: «server_log.txt» and then parse it with a regular expression, find the IDs of your opponents there, then request the game history in OpenDota or Dotabuff. This method has disadvantages — if the opponents made their game profile hidden in Dota 2, then you will not receive any information about it. There is one more point that I forgot to take into account — the data may be outdated, but in the code this can be easily fixed by adding a time filter.

Attention: link code
can BSoD your eyes.

 import fs from "fs";

const DEFAULT_FILE =
  "C:\\Program Files (x86)\\Steam\\steamapps\\common\\dota 2 beta\\game\\dota\\server_log.txt";

// Парсим все ID в строке
const getDotaIdsFromLine = (line) => {
  let playersRegex = /\d:(\[U:\d:(\d+)])/g;
  let playersMatch;
  let dotaIds = [];
  while ((playersMatch = playersRegex.exec(line))) {
    dotaIds.push(playersMatch[2]);
  }
  return dotaIds;
};

const getState = () => {
  return new Promise((res) => {
    // ищем последнюю строку со словом Lobby
    fs.readFile(DEFAULT_FILE, (err, data) => {
      const rowString = data.toString();
      const startIndex = rowString.lastIndexOf("Lobby");
      const finishIndex = rowString.indexOf("\n", startIndex);
      const lobbyString = rowString.slice(startIndex, finishIndex);

      res(getDotaIdsFromLine(lobbyString));
    });
  });
};

export const getSteamIDs = () => {
  return getState();
};

  

After, it will be great to bring this out too, so it was decided to make a separate React application on localhost:3002. Without design, it looks completely terrible, but it was already just a sporting interest and in general I don’t use it. It contains information about the past ten games. A «Ban this id» button to remove friends you play with from this statistic and a link to your Dotabuff profile if you want more details.

This application could also be beautifully designed as an Electron overlay and launched at the stage of choosing heroes, but it seems that I play too many games and spend little time on really useful things 🙂

What else was tried:

• I tried DLL Injection from the last article and reading memory with Rust, but there was a big flaw in that all pointers to data structures found lived before the game was updated, so this idea was abandoned .

• Attempt to create a matchmaking service based on ML training by downloading games from OpenDota.com or from the same Valve servers (failure — although I think I just failed to prepare the ML part correctly)

• Parsing Dota 2 replays — it’s not difficult, Protobuff is used and all structures are easily found on github. But what to do next with this huge amount of data?

Conclusion: integrating with Dota2 is not difficult, you can do a quick analysis right during the game, when watching eSports games you can make a huge number of beautiful overlays for Twitch streams, you can also develop this topic towards a retrospective analysis from replays, which is more likely everything will be useful to professionals.

I hope you were interested in reading about how I collected cheats on my knee (actually a good question — are they cheats or not?), and even on JS, if there are spelling or lexical errors, then please write to the PM , thank you for your attention.

Do game devs use C++?

C++ plays an important role in today’s game development ecosystem. C++ is used in the source code of many major game engines, such as Unreal and Unity, allowing developers to build more high-performant games. Let’s see why C++ is a better programming language for game development.

Does Dota 2 use the source engine?

The Source Engine is a 3D video game engine developed by Valve for the creation and development of games. Several games have been produced by way of this engine, including Dota 2.

Why is Dota 2 so addictive?

One of the main reasons for developing an addiction to Dota is the escape from reality that the game offers. A lot of people who are addicted to video games often use them to run from difficult situations and negative thoughts or emotions that they might be struggling to deal with.

Dota 2 heroes don’t know the proper item names.

https://youtube.com/watch?v=Vv6eXuwFCLA%3Ffeature%3Doembed

Is Dota 2 good for brain?

And yes, any sort of mental exercise is good, so if right now the most stimulating thing in your life is watching makeup tutorials, DotA will give you plenty of opportunities to flex your brain muscle.

What is the easiest coding language for games?

The easiest languages to learn for game development are probably those with a syntax similar to English, as it makes them more readable and beginner-friendly. Python and JavaScript are both great choices in this regard. If you do have some coding experience, you should also consider Lua, Java, and C#.

Задача

В полной версии игры сражаются игроки 5 на 5, но в некоторых
турнирах бывают
и игры 1 на 1. Наш бот играл по стандартным турнирным правилам – мы не добавляли специальные упрощения для ИИ.

Бот работал со следующими интерфейсами:

• Наблюдение: API, разработанные так, чтобы у него были те же возможности, что и у живых игроков, касающиеся героев, других персонажей игры и поверхности рядом с героем. Игра частично наблюдаема.

• Действия: доступные через API, с частотой, сравнимой с человеческой, включая движение к определённому месту, атаку и использование предметов.

• Обратная связь: бот получает вознаграждения за победу, а также простые параметры, такие, как здоровье и ластхиты
.

Мы выбрали несколько десятков предметов, доступных для бота, и выбрали из них один для изучения. Также мы отдельно тренировали блокирование крипов при помощи традиционных техник обучения с подкреплением, поскольку это происходит до того, как появляется соперник.

Бот играет против Arteezy

Is DotA made by C++?

While Lua is dynamically typed, the DOTA 2 engine is written primarily in C++, which is statically typed.

Уязвимости бота

Хотя SumaiL назвал бота «непобедимым», он всё ещё может запутаться в ситуациях, слишком отличающихся от того, что он видел. Мы запустили его на одном из мероприятий, проходивших на турнире, где игроки играли более 1000 игр с целью победить бота всеми возможными способами.

Удачные уязвимости попали в три категории:

• Перетягивание крипов. Можно постоянно заставлять крипов с линии гнаться за вами сразу после их появления. В результате за вами по всей карте будет бегать несколько десятков крипов, и вражеские крипы уничтожат башню бота.

• Orb of venom + wind lace: дают вам преимущество в скорости передвижения над ботом на первом уровне и позволяют быстро нанести урон.

• Raze на первом уровне: требует навыков, но несколько игроков класса 6-7K смогли убить бота на первом уровне, удачно выполнив 3-5 заклинаний за короткое время.

Исправление проблем для матчей один на один будет похоже на исправление бага с Pajkatt. Но для матчей 5 на 5 эти проблемы уязвимостями не являются, и нам будет нужна система, способная справиться со странными ситуациями, которые она не видела до этого раньше.

Is Dota 2 a turbo?

Turbo mode joined Dota 2 after the Dueling Fates 7.07 update, and it allowed new and casual Dota 2 to get in tune with the game. They can play any hero in this mode and determine which hero they choose in battles. Today, we will determine five ways to become a better player at Dota 2 if you spend time in turbo mode.

What language is DotA?

«Vi sitter i Ventrilo och spelar DotA» (Swedish for «We’re sitting in Ventrilo, playing DotA» and shortened to «DotA») is a song by Swedish musician Basshunter which samples a remixed version of the French song «Daddy DJ» by Daddy DJ.

What is the average IQ in Dota 2?

This would ready the player for real world dota. considering the amount of south americans and muslims that play this game because it is free-to-play on steam, the average IQ of a dota 2 player is the same as the average IQ of a person in the free-to-play community in general. somewhere around 70.

What engine is DotA built on?

Source 2 is a video game engine developed by Valve. The engine was announced in 2015 as the successor to the original Source engine, with the first game to use it, Dota 2, being ported from Source that same year. Since then, Valve’s Artifact, Dota Underlords, and Half-Life: Alyx have all been made with the engine.

Why is Java not used for games?

Poor Console Support: Ironically, for one of the most portable programming languages available, Java is less portable than others when it comes to targetting game consoles. The dominant consoles in the market today simply don’t have a JVM to run Java code.

The International Tournament

Our approach, combining playing with ourselves and learning from outside, allowed us to significantly increase the game of our bot from Monday to Thursday during the tournament. On Monday evening, Pajkatt won using an unusual item build. We have added this build to the list of available items.

Around 1 pm on Wednesday, we tested the latest version of the bot. The bot was losing a lot of health after the first wave. We decided we needed to rollback, but then we noticed that the subsequent game was amazing, and the behavior in the first wave was just bait for other bots. Subsequent games with itself solved the problem when the bot learned to counter the bait strategy. And we combined that with a Monday bot for the first wave only, and finished just 20 minutes before Arteezy showed up.

Arteezy played a match with our 7.5K tester. Arteezy was winning the game, but our tester managed to surprise him with a strategy he peeped from the bot. Arteezy later remarked that this strategy was once used against him by Paparazi, and that it is rarely used.

Pajkatt beats the Monday bot. He lures the bot, and then uses regeneration.

Does Dota 2 increase IQ?

A study conducted at the University of York found a correlation between young people’s skill at two popular video games (Dota 2 and League of Legends) and high intelligence levels.

Does Dota use Java?

The GUI of the game is implemented using Valve’s Panorama technology which has its own JavaScript engine for UI programming. Older versions of the game also used Autodesk’s Scaleform technology in which you use ActionScript instead of JavaScript to program your UI.

Is Dota written in Lua?

Scripting in Dota 2 is handled by the VScript virtual machine using the Lua programming language. Lua will be launched at run time when Dota 2 loads your add-on and can manipulate most facets of the game.

Is Dota CPU or GPU heavy?

Dota 2 is a CPU intensive game. It mostly relies on ur CPU than ur GPU. Yea it depends on what you really mean. If you say that you can go overkill then go overkill like getting an i9 10900kf and RTX 3080TI or a RYZEN 9 5900X and a Radeon RX6900XT.

Infrastructure

We are not yet ready to discuss the internal features of the bot — the team is working on a solution to the problem with the game 5 on 5.

The first step of the project was to understand how to run Dota 2 in the cloud on a physical GPU. The game gave an incomprehensible error in such cases. But when running on GPU on Greg’s desktop (during the show, this desktop was taken on stage), we noticed that Dota loads with a monitor connected, and gives the same message without a monitor. Therefore, we set up our virtual machines so that they pretend that a physical monitor is connected to them.

At that time, Dota did not support dedicated servers, which means that running with scaling and without a GPU was possible only in the version with a very slow soft rendering. We then stubbed out most of the OpenGL calls other than those needed for loading.

At the same time, we wrote a scripted bot — as a benchmark for comparison (in particular, because built-in bots do not work well in 1v1 mode) and to understand the semantics of the API for bots
. The script bot gets to 70 last hits in 10 minutes on an empty path, but still loses to fairly good players. Our best 1v1 bot goes up to around 97 (it destroys the tower earlier, so we can only extrapolate), and the theoretical maximum is 101.

Bot plays against SirActionSlacks. The strategy of distracting the bot with a crowd of couriers did not work

What big games use Java?

• 7 Best Games Written in Java. Modesta Mice. .
• Wakfu. As a colorful, tactical turn-based MMORPG, Wakfu is quite a unique gem. .
• Worms: A Space Oddity. Adapting the classic Worms turn-based formula to the Nintendo Wii, developer Team17 opted to employ Java. .
• Saints Row 2 (Mobile) .
• SimCity. .
• Spiral Knights. .
• RuneScape. .
• Minecraft.

What is DotA MMR based on?

Dota 2 MMR FAQ

It’s basically an algorithm used to keep a game with a huge skill difference as fair as possible. It’s based on your performance and win/loss ratio, and is used to determine the skill level of players in the game.

What is Dota 2 scripting?

The Dota 2 script calculates the damage output and enemy situation. By doing the math, the script deduces the “optimized” decision on when to do last hit or when to deny.

What engine is LOL written in?

Riot made their own proprietary game engine with C++.

Is Dota 2 skill based?

All PvP matchmaking is based on an Matchmaking Rating (MMR) similar to the Elo system. Players of roughly equal skill will be placed in the same game.

What games are made entirely in C++?

Lastly, knowing C++ will also help you quickly learn C#. Video games developed using C++ include Witcher 3, Counter-Strike, Doom III Engine, World of Warcraft, King Quest, Football Pro and Invictus, among many others.

Who programmed Dota 2?

IceFrog. IceFrog (born 1983 or 1984) is the pseudonymous lead designer of Defense of the Ancients and Dota 2.

Пять на пять

Игра 1 на 1 – сложная задача, но 5 на 5 – это океан сложности. Нам нужно будет расширить пределы возможности ИИ, чтобы он смог с ней справится.

Привычным образом мы начнём с копирования поведения. В Dota проходит порядка миллиона публичных игр в день. Записи матчей хранятся на серверах Valve две недели. Мы скачиваем каждую запись игры на экспертном уровне с прошлого ноября, и набрали набор данных объёмом в 5,8 млн игр (каждая игра – примерно 45 минут с 10 игроками). Мы используем OpenDota
для поиска записей и перечислили им $12000 (что в десять раз больше того, сколько они хотели собирать за год) для поддержки проекта.

У нас ещё много идей, и мы нанимаем
программистов (интересующихся машинным обучением, но не обязательно экспертов) и исследователей нам в помощь. Мы благодарим Microsoft Azure и Valve за поддержку в нашей работе.