1. League of Legends Ontology
By Hannah De los Santos and Anders Maraviglia

2. Base Ontology Structure: Champions
Hannah

3. Base Ontology Structure: Items
Hannah

4. Base Ontology Structure: Teams
Hannah

5. How We Answer Competency Questions
Team Questions:
We have our queries return all roles each champion (on a team) can play, assign each role to a champion so that all roles on a team are unique.
A discussion on properly using a ‘statistics’ ontology to do this will come later.
Item Questions:
Return BFS style set of items that are next in the build, given the set of items the user has and filtered by the gold available so that only affordable items are shown.
We use a java program to generate these queries.
Anders

6. Simple SPARQL Team Query
Question: “What role is the champion Azir when the rest of the team is made up of the champions Garen, Jinx, Nidalee, and Thresh?”
Answer: “Azir should be a Mage.”
Anders

7. Simple SPARQL Item Query
Question: “What items should the plugin recommend the user build if they only have Doran’s Blade, Warding Totem, and 100 gold available?”
Answer: “The plugin should recommend the user build ‘Health Potion 2’ and ‘Health Potion’ with the gold the user would require to buy these items.”
Anders

8. SPARQL Item Query
Question: “What items (from the build the ontology selected) should the plugin present to the user (playing the champion Jinx) when he/she opens the shop for the first time that game with 550 gold?”
Answer: “The items ‘Doran’s Blade,’ ‘Health Potion,’ ‘Health Potion,’ ‘Warding Totem’ should be displayed.
We use the Java program to build us this query and filter any duplicate results from the query result set.
Anders

9. Individuals Ontology Structure: Team Instance
Hannah

10. Individuals Ontology Structure: Champion Instance
Hannah

11. Individuals Ontology Structure: Item Tree Instances
Hannah

12. Considerations in Modeling Differently
Java Programs
Using Apache Jena, we can load in ‘.ttl’ ontology files, construct queries from a template, and run those queries using the built in reasoner (whose results mirror those of Protege).
The challenge in using a Java-based approach is ensuring that the queries are actually doing the ‘heavy lifting.’
Statistical measures for items and champion roles (discussed later).
Anders

13. The Java Query Template
There are 4 elements of our item queries that are taken as inputs and dynamically generate lines of the result query:
Gold avaliable:
Filter all items we select in the query by affordability.
Inventory Space:
Only show as many items as a user has space for in their inventory.
Root items:
Use all owned items as points to look for next items in the build (children of owned items).
Preclude owned items:
Filter results by not displaying items already present in the user's inventory.
Anders

14. Remaining Modeling Issues
STATISTICS
Challenges with picking a set of items that represent the build in competency question 5 revolve around using a non-trivial ‘statistics’ ontology.
This also affects how we handle champion role selection.
We need to restructure our ontology to properly incorporate this new ontology.
Java code needs some cleanup
Minor computational issues with properly filtering items by gold cost in some unique circumstances.
Anders

15. OOPS! Output and Changes
Deleted artefacts from previous ideas: Transformation and ChampionSpecific
Double checked all missing definitions reported and found a few missing: nextItemInBuild, hasDamageTypeString, hasTeamDamageType, among others
Hannah

16. OOPS! Output Considerations
Problems with OOPS! Output:
Many of the problems had to do with the imported ontologies, which we didn’t care about fixing
This cluttered up the output and made it hard to find our own IRIs
Their importance factors seemed inaccurate
Unconnected ontology elements, which seemed important to us, were minor
Equivalent properties not being declared, which was not important, was important
Possible additional features to OOPS!:
Check for specific annotations (such as rdfs:label or dcterms:source)
List IRIs alphabetically
Hannah

17. Next Steps
Clean up java program to fully handle add edge cases and produce queries that answer all item related competency questions.
Incorporate the new statistics ontology so we may properly extract the set of items we have been referring to as ‘builds.’
Anders

18. Questions?