Stories with Tag League of Legends

• League of Legends data scraping the hard and tedious way for fun

  permalink

  Posted: 2025-02-12 11:11:38

  Verbose tl;dr

  The author details their complex and manual process of scraping League of Legends match data, driven by a desire to analyze their own gameplay. Lacking a readily available API for detailed match timelines, they resorted to intercepting and decoding network traffic between the game client and Riot's servers. This involved using a proxy server to capture the WebSocket data, meticulously identifying the relevant JSON messages containing game events, and writing custom parsing scripts in Python. The process was complicated by Riot's obfuscation techniques and frequent changes to the game, requiring ongoing adaptation and reverse-engineering. Ultimately, the author succeeded in extracting the data, but acknowledges the fragility and unsustainability of this method.

  This blog post chronicles the author's intricate journey into the realm of data scraping, specifically targeting information from the popular online game League of Legends. Motivated by a personal desire to analyze game data beyond the limitations of the readily available Riot Games API, the author embarks on a challenging but ultimately rewarding expedition into the depths of web scraping.

  The post begins by outlining the author's initial attempts to extract data using conventional methods like the official API and community-developed tools. Finding these approaches lacking in the specific data points they sought, the author details the pivot towards a more hands-on, and significantly more complex, strategy: directly parsing the HTML structure of the League of Legends website. This approach presented a formidable challenge due to the dynamic nature of the site’s content, which is heavily reliant on JavaScript for loading and displaying information.

  The author meticulously describes the process of reverse-engineering the website's functionality. This involved carefully inspecting network requests, dissecting JavaScript code, and understanding how the game client interacts with the server to fetch and render data. The post highlights the complexity of this undertaking, emphasizing the numerous obstacles encountered, including navigating obfuscated code, dealing with asynchronous loading patterns, and interpreting complex data structures.

  The core of the author’s solution involved leveraging browser automation tools, specifically Selenium and Chromium, to simulate user interaction with the website. This allowed the author to trigger the JavaScript execution necessary to populate the page with the desired data, which could then be extracted by parsing the rendered HTML. The post delves into the specifics of using Selenium, outlining the steps involved in automating navigation to specific match history pages, handling login procedures, and waiting for dynamic content to fully load.

  The author further elaborates on the intricacies of data extraction, detailing the use of regular expressions and other parsing techniques to isolate relevant information from the complex HTML structure. The post acknowledges the fragility of this approach, noting its susceptibility to changes in the website's layout and the potential need for frequent adjustments to the scraping logic.

  Finally, the post concludes with a reflection on the lessons learned and the overall success of the project. While acknowledging the arduous and time-consuming nature of this method, the author emphasizes the valuable experience gained in understanding web technologies and the satisfaction of obtaining the desired data. The post implicitly suggests that this direct scraping approach, while complex, provides a powerful alternative when conventional methods fall short in providing access to specific data points.

  • League of Legends
  • data scraping
  • web scraping
  • game data
  • Riot API
  • Python
  • Tutorial
  • Data Analysis
  • Esports
  • Gaming

  Summary of Comments ( 26 )
  https://news.ycombinator.com/item?id=43024173

  Verbose tl;dr

  HN commenters generally praised the author's dedication and ingenuity in scraping League of Legends data despite the challenges. Several pointed out the inherent difficulty of scraping data from games, especially live service ones like LoL, due to frequent updates and anti-scraping measures. Some suggested alternative approaches like using the official Riot Games API, though the author explained their limitations for his specific needs. Others shared their own experiences and struggles with similar projects, highlighting the common pain points of maintaining scrapers. A few commenters expressed interest in the data itself and potential applications for analysis and research. The overall sentiment was one of appreciation for the author's persistence and the technical details shared.

  The Hacker News post "League of Legends data scraping the hard and tedious way for fun" has generated a modest discussion with a few interesting comments. The comments mostly revolve around alternative approaches to data scraping, specifically for League of Legends, and the challenges faced when relying on unofficial APIs.

  One commenter points out that the Riot API, while official, can be quite limiting and slow. They suggest exploring community-driven projects like the "Champion.gg for Desktop" project, which uses undocumented APIs and has faced its share of challenges with Riot's changes. This commenter highlights the trade-off between using official, albeit limited APIs and venturing into unofficial ones that offer richer data but risk breaking with game updates.

  Another commenter mentions their personal experience with scraping League of Legends data. They specifically mention difficulties encountered when dealing with the dynamic loading of elements on the League of Legends client, making traditional scraping methods tricky. They underscore the complexity involved in keeping up with the constantly evolving structure of the client.

  A third comment provides a direct link to the "Champion.gg for Desktop" GitHub repository mentioned earlier in the discussion. This allows other users to readily explore the project and potentially contribute or learn from its implementation.

  The discussion also briefly touches on the broader topic of web scraping ethics and legality, with one user cautiously mentioning potential terms of service violations. However, this aspect isn't explored in great detail.

  Overall, the comments on the Hacker News post provide valuable insights into the challenges and considerations involved in scraping data from online games like League of Legends. They showcase the trade-offs between utilizing official APIs and resorting to unofficial methods, emphasizing the complexities that arise from dynamic content loading and constant updates from game developers. While not a lengthy or highly active discussion, the existing comments provide practical perspectives and relevant resources for anyone interested in similar data scraping endeavors.

• Using Linear Programming to find optimal builds in League of Legend

  permalink

  Posted: 2025-01-22 19:02:07

  Verbose tl;dr

  The blog post explores using linear programming to optimize League of Legends character builds. It frames the problem of selecting items to maximize specific stats (like attack damage or ability power) as a linear program, where item choices are variables and stat targets are constraints. The author details the process of gathering item data, formulating the linear program, and solving it using Python libraries. They showcase examples demonstrating how this approach can find optimal builds based on desired stats, including handling gold constraints and complex item interactions like Ornn upgrades. While acknowledging limitations like the exclusion of active item effects and dynamic gameplay factors, the author suggests the technique offers a powerful starting point for theorycrafting and understanding item efficiency in League of Legends.

  This blog post explores the application of linear programming (LP) to optimize item builds in the video game League of Legends. The author posits that finding the mathematically optimal combination of items for a given champion in a specific game scenario is a complex problem well-suited for this optimization technique.

  League of Legends involves two teams of players controlling powerful characters, called champions, who battle to destroy the opposing team's base. Each champion can purchase items that enhance their stats, such as attack damage, ability power, armor, and magic resistance. The vast number of possible item combinations makes it challenging for players to determine the most effective build, especially considering that optimal builds vary depending on the enemy team composition and the current state of the game.

  The author proposes formulating the item optimization problem as a linear program. The objective function aims to maximize a chosen metric, such as damage output or survivability, represented as a linear combination of the relevant stats. This function is subject to several constraints. One key constraint is the budget limitation imposed by the in-game gold economy. Other constraints include the maximum number of each item that can be purchased (usually limited to one unique item) and the item build path dependencies, as some items require prerequisite components.

  The blog post then delves into the specifics of setting up the LP problem. It details how various in-game statistics, such as attack damage, ability power, armor, magic resistance, critical strike chance, and cooldown reduction, can be incorporated into the objective function and constraints. The author explains how these stats contribute to a champion's overall effectiveness and how they can be modeled linearly, acknowledging the inherent limitations and simplifications involved. Furthermore, the post discusses incorporating situational factors into the optimization process, including adjusting the objective function based on the enemy team's composition and focusing on maximizing damage against specific types of defenses (armor or magic resistance).

  The author acknowledges the inherent challenges and complexities of perfectly modeling League of Legends within the framework of linear programming. Factors such as item actives, unique item passives, and complex interactions between champions and items are difficult to represent linearly. Despite these limitations, the post suggests that LP can offer valuable insights into optimal item builds and serve as a powerful tool for understanding the underlying mathematical relationships between item stats and champion effectiveness. The author concludes by suggesting potential improvements and future directions for this approach, including exploring different objective functions, incorporating more sophisticated models of in-game mechanics, and potentially integrating the optimization process into a real-time tool to assist players during matches.

  • League of Legends
  • Linear Programming
  • optimization
  • Game Theory
  • Character Builds
  • Item Builds
  • Gaming
  • algorithms
  • Data Analysis
  • Modeling
  • Simulation
  • Esports
  • Competitive Gaming
  • LoL
  • Video Games

  Summary of Comments ( 15 )
  https://news.ycombinator.com/item?id=42796292

  Verbose tl;dr

  HN users generally praised the approach of using linear programming for League of Legends item optimization, finding it clever and interesting. Some expressed skepticism about its practical application, citing the dynamic nature of the game and the difficulty of accurately modeling all variables, like player skill and enemy team composition. A few pointed out existing tools that already offer similar functionality, like Championify and Probuilds, though the author clarified their focus on exploring the optimization technique itself rather than creating a fully realized tool. The most compelling comments revolved around the limitations of translating theoretical optimization into in-game success, highlighting the gap between mathematical models and the complex reality of gameplay. Discussion also touched upon the potential for incorporating more dynamic factors into the model, like build paths and counter-building, and the ethical considerations of using such tools.

  The Hacker News post titled "Using Linear Programming to find optimal builds in League of Legend" generated several interesting comments discussing the application of linear programming to optimize in-game item builds.

  Several commenters expressed enthusiasm for the approach and its potential. One user highlighted the cleverness of using linear programming for this purpose, finding it a refreshing departure from the typical machine learning approaches often discussed. They also appreciated the clear explanation provided in the blog post.

  Some users delved into the specifics of the model. One pointed out the challenge of defining the objective function, questioning how "best" is defined and whether maximizing damage output is always the optimal strategy. They also raised the issue of dynamic gameplay, where the optimal build might change depending on the opposing team's composition and in-game developments. Another user elaborated on this point, mentioning the difficulty of capturing complex interactions, such as crowd control abilities and item actives, within the linear programming framework.

  The discussion also touched upon the practical limitations of using such a tool in real-time gameplay. One commenter questioned the feasibility of calculating the optimal build quickly enough during a match. Another user suggested that pre-calculating optimal builds for various scenarios could be a more practical approach.

  A few users shared their own experiences with similar optimization problems in other games, drawing parallels and suggesting potential improvements. One user mentioned using linear programming for optimizing builds in Path of Exile, highlighting the complexity introduced by unique item affixes. Another suggested exploring other optimization techniques, such as genetic algorithms, as alternatives to linear programming.

  The limitations of modeling the game within a linear framework were also discussed. One commenter noted that certain aspects of League of Legends, such as critical hit chance and lifesteal, introduce non-linear elements that might not be accurately captured by a linear model.

  Finally, there was some discussion about the blog post itself. A user praised the author for their clear explanation and for providing the source code, enabling others to experiment with the model. Another user suggested incorporating item interactions, such as combinations that grant unique bonuses, into the model.