I’ve been a trifle remiss in posting of late, especially with the big changes which have come out lately. Sorry about that.

However, I have kept on top of getting the SDE conversions out, including the blueprint details, yanked out of the new blueprints.yaml file, and shoved into appropriate database tables. The good news is, they’re a lot easier to work with than the old versions. The not so good news is, I’ve not been back porting them into MS SQL server, so that’s a step you’ll have to manage yourself (Should be pretty easy, tbh. If you have trouble, give me a yell, and I’ll write something up)

The Tables:

ramActivities

This isn’t actually a new table. it’s just handy for knowing which activity id is which actual activity. such as 1 is manufacturing.

industryActivity

If you need to know how long it takes to do something, this is your table. Blueprint type id,  activityid, time in seconds to do it. This is a time unmodified by TE, so you’ll be reducing it.

industryActivityMaterials

This is the core table for most of you good folk. blueprint type id, activity id, material id, quantity, and if it’s consumed. With the changes coming in phoebe, consume is deprecated. I’m leaving it in, set to 1 for everything, so things won’t break, but it’ll go away in time.

industryActivityProbabilities

For invention and reverse engineering. No longer do you need to create a table, CCP provide all the information.

industryActivityProducts

The outputs from a blueprints, with its various activities. Handy, when you want to be able to determine what is invented from what. Also includes the number of items created in a batch, or the number of runs from invention and reverse engineering.

industryActivityRaces

This one will be going away. Prephoebe, it let you know what you could reverse engineer from what, race wise. That’s no longer needed.

industryActivitySkills

The skills to do each activity.

industryBlueprints

I needed somewhere to keep the maxProductionLimit value. That’s what this table is for.

As you can see, everything is a lot simpler to query now, everything tied to the blueprint type id, rather than to the final product. In the examples below, I’m using expanded Cargohold IIs. 1320 is the blueprint, 1319 is the actual thing.

[lang=sql]
select typeName,materialTypeID,quantity
from industryActivityMaterials iam
join invTypes on (iam.materialTypeID=invTypes.typeID)
where activityid=1 and iam.typeid=1320
[/lang]
To make something.

[lang=sql]
select typename,materialTypeID,iam.quantity
from industryActivityMaterials iam
join industryActivityProducts iap on (iap.typeid=iam.typeid)
join invTypes on (iam.materialTypeID=invTypes.typeID)
where iam.activityid=8 and iap.activityid=8 and iap.producttypeid=1320
[/lang]
To invent the blueprint to make them. This gives the materials for the invention, but not the required blueprint. To get that, you could just pull iam.typeid.

The formulas for using all these figures have been drawn together by Qoi, in this forum post https://forums.eveonline.com/default.aspx?g=posts&t=362493 which is handy. The core one is:

quantity after adjustment= max(runs,ceil(round((quantity(1-(ME/100))(1/(100-facility bonus))(1-(team bonus 1/100))(1-(team bonus 2/100))),2)))

The round, in case you’re curious, is there to eliminate a pesky floating point rounding error, which leads to some materials being 1 too high.

I loathe importXML. Truly despise it.  Sure, it works for some things, but the moment that you want to get more than a single piece of XML data back from each call, it becomes a problem.

Sure, you can have an importxml call which has multiple attributes in the xpath entry, but that depends on the site never changing the order that comes back. Which isn’t the world’s best idea.

There is, however, a solution. It’s one that I’ve been looking at recently, when Mynnna linked a forum post to me about someone loading asset information into google docs. It’s a neat solution, especially because the asset api is a more complicated one, with nesting (Assets can exist within Assets).

That got me looking at other APIs, and led to the creation of a new github repository where I’m keeping the code of some new custom functions for loading data. I’m not using them myself, but that’s because I’m a bit of a database snob. I can do things there which would be an absolute PITA to do in a spreadsheet. However, I am a code junkie, so this lets me scratch that itch (I can do this better! Tada!)

I thought I’d explain a little of what goes into these functions, basing it off the simplest of them. The outpost loader function.

function loadOutposts(){
  var outposts= new Array();
  var url = "https://api.eveonline.com/eve/ConquerableStationList.xml.aspx";
  var parameters = {method : "get", payload : ""};
  var xmlFeed = UrlFetchApp.fetch(url, parameters).getContentText();
  var xml = XmlService.parse(xmlFeed);
  if(xml) {
    var rows=xml.getRootElement().getChild("result").getChild("rowset").getChildren("row");
    for(var i = 0; i < rows.length; i++) {
      outpost=[rows[i].getAttribute("stationID").getValue(),
                 rows[i].getAttribute("stationName").getValue(),
                 rows[i].getAttribute("stationTypeID").getValue(),
                 rows[i].getAttribute("solarSystemID").getValue(),
                 rows[i].getAttribute("corporationID").getValue(),
                 rows[i].getAttribute("corporationName").getValue()
                 ]
      outposts.push(outpost);
    }
  }
  return outposts;
}

If you want to have a function that returns a bunch of rows and columns, you have to build an array of data, and return that.

An array is a simple idea. It’s way of bundling up information. A single dimensional array is a list. A two-dimensional array is a table (like a spreadsheet). You can have more levels, which become somewhat harder to visualise (3 dimensional: a table where a cell can contain lists of data. and so on)

So you have to take the XML data, and format it into a 2 dimensional array. Thankfully, this works easily. Each row in the API, becomes a row in the array. You build a list, and add it to the bottom at the total array (known as a push)

Step one: get the XML. that’s what the UrlFetchApp.fetch line does. At this point, you just have a bunch of text, which happens to be XML.
Step two: turn the text into a data structure your code can deal with. That’s the XmlService.parse line. You now have a data structure that your code can access, and loop through.
Step three: Make sure it was actually XML you had. If the parser couldn’t handle it, it’d have made the xml variable false, so the if (xml) test would fail.
Step four: loop through it. We don’t care about anything but the rows, so we burrow down to that level, (the getChild and getChildren line). With that split off, we now have an array (a 1 dimensional list) of rows. The for loop iterates through that, with a counter that points to each entry. The address of the entry/
Step five: Create a list of data about each outpost. Because we’re working with a proper XML engine here, it’s case sensitive on attribute names, unlike importXML.
Step six: push the list of data about a specific outpost onto the bottom of the list of outposts
Step seven: Repeat steps five and six until it’s finished.
Step eight: Hand the array back, with a return statement.

That’s pretty much the core of all the functions. Some are a little more complex, because they’re turning typeids into typenames and so on. That’s done by generating an array where the address is the typeid, and the other entry is the name. You can see an example of that in the MarketOrders function, for stations and typeids. If you’re wondering why I’m adding a _ to it, it’s to make sure it’s treated as text, so no funny business with number comparison or arrays with holes happens.

For the Market Orders function, you’ll also notice it requires the moment.js library loaded. This is because the scripting engine behind google sheets handles dates very badly. moment.js makes it far easier to do something like add 90 days to a date.

Anyway, the required steps to get one of the scripts working (excluding anything like the moment.js library, and additional sheets, mentioned in the comments for specific scripts)

• open up a new, or existing sheet.
• Tools menu -> Script editor
• If you haven’t done this before, for this sheet, it’ll ask you what you want to create a script for. pick ‘Blank Project’
• Delete the text which it shows ( the function myFunction() { } stuff. )
• paste in the text for the function of mine you want to add.
• As long as there aren’t other specific steps, you’re now done. The Eve Central and outpost scripts don’t need anything else.

At this point, you can just use the functions in your regular sheets 🙂

If there are any APIs you can’t get working, give me a yell, and I may be able to help.

More and more things are being put into EVE’s new public CREST endpoints.

For people who do industry, the most important 2 which are now there, are Cost Indexes, and adjusted prices.

Now, I’m not much of one for using spreadsheets myself, preferring to code a custom solution, but I know there’s a large group of people who won’t live without them.

Lockefox has put together a solution for googledocs. I’ve not used it, but it probably works well. If you need it, go take a look.

That leaves Excel. It used to be that working with things in Excel was easier, as it had better handling for loading entire XML sheets, rather than single cells. Unfortunately, it has no native JSON support. Even if it did, it’s nested data, which makes it somewhat harder to pull out.

Looking at the cost indexes, first you have an array of solar systems, and within each of those, you have an array of cost indexes. So you have to manually flatten that 3d data structure, into a 2d one.

I spent some time working on this, and came up with: costIndexes

It’s a macro enabled Excel workbook built in excel 2010, which loads in the cost indexes. I leave price data as an exercise for the reader. It takes a while to work but that’s because it’s processing a relatively large file, and it probably isn’t the most efficient way of doing it.

Now, to explain how it works, it’ll be easier if you open up Visual basic, from the development ribbon (file->options->customize ribbon, tick the development tab)

It’s including 3 files from http://www.ediy.co.nz/vbjson-json-parser-library-in-vb6-xidc55680.html. The JSON modules, the cJSONScript and cStringBuilder class modules

Then you have the following subroutine in the source for the workbook. Finally, you have a button which calls the Test() subroutine. All in all, it’s actually pretty simple (because the json parser makes it easy)

Long term, there are probably better ways to do it, using .net or similar. But it works.

Sub Test()
    Dim oHttp As Object
    Dim jsonText As String
    Dim jsonObj As Dictionary
    Dim jsonRows As Collection
    Dim jsonRow As Dictionary
    Dim costInex As Collection
    Dim ws As Worksheet
    Dim currentRow As Long
    Dim startColumn As Long
    Dim i As Long
    
    Set oHttp = CreateObject("MSXML2.XMLHTTP")
    If Err.Number <> 0 Then
        Set oHttp = CreateObject("MSXML.XMLHTTPRequest")
        MsgBox "Error 0 has occured while creating a MSXML.XMLHTTPRequest object"
    End If
    On Error GoTo 0
    If oHttp Is Nothing Then
        MsgBox "For some reason I wasn't able to make a MSXML2.XMLHTTP object"
        Exit Sub
    End If
    
    oHttp.Open "GET", "https://public-crest.eveonline.com/industry/systems/", False
    oHttp.Send
    
    'Create a real JSON object
    jsonText = oHttp.responseText
    
    Set ws = Worksheets("CostIndexes")
    
    
    'Parse it
    Set jsonObj = JSON.parse(jsonText)
    
    'Get the rows collection
    Set jsonRows = jsonObj("items")
    
    'Set the starting row where to put the values
    currentRow = 1
    
    'First column where to put the values
    startColumn = 1 'A
    
    'Loop through all the values received
    For Each jsonRow In jsonRows
        currentRow = currentRow + 1
        ws.Cells(currentRow, startColumn).Value = jsonRow("solarSystem")("id")
        For Each costIndex In jsonRow("systemCostIndices")
            ws.Cells(currentRow, costIndex("activityID") + 1).Value = costIndex("costIndex")
        Next costIndex
    Next jsonRow
End Sub