evego

package module
v0.0.0-...-efc180c Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 8, 2021 License: Apache-2.0 Imports: 4 Imported by: 4

README

evego

Build Status GoDoc

evego is a library for your Internet spreadsheets spreadsheets; sometimes, a spreadsheet isn't actually sufficient. It does not currently slice, dice, or make Julienne fries. For that matter, it doesn't even interface with the user; it's just a back-end library.

Current status

forthebadge

This library should be considered a prototype. The exported API is absolutely subject to change for the near future, and suggestions for changes are encouraged if something could be implemented better. (On a related note, if you use evego in your own code, please let me know.)

This library is archived as I haven't touched it in years.

Dependencies

External routing functionality is required for the market features (in particular, determining which buy orders are available to sell to at a given station). Because I'm not going to reimplment Dijkstra's algorithm, we use one of three options:

To spatialize the SQLite data export, use spatialize-sqlite.sh; to spatialize the PostgreSQL data export, see the readme file in db/pgsql.

N.B. While PostgreSQL works, I haven't set it up for the Travis builds yet. Just so you know.

To-do list

  • Industry
  • Reprocessing calculations
  • Mining planner
  • Production scheduling
  • What is this item used for?
  • Planetary interaction
  • Required PI infrastructure for a given blueprint
  • Market
  • Inventory management
  • Suggest which blueprints to build based on market activity

Development

We like test cases. Unit tests are written using GoConvey, and there should be as close to 100% coverage as possible. While unit tests should ideally be included with pull requests, don't let that stop you from submitting one if you're not sure how to test it. Higher-level tests would also be a good idea.

This repository includes the subset of the EVE Static Data Export necessary to run the test cases. If you add test cases that use data not in this subset:

  • Add the missing items (and tables, if necessary) to make-test-db.sh;
  • Rerun that script against Fuzzysteve's SQLite conversion of the full SDE;
  • Run the spatialize.sh script to generate the routing table for jump path calculations; and
  • Add the new version of testdb.sqlite to your changeset.

By default, the test suite uses the provided SQLite excerpt; to test against PostgreSQL, set the EVEGO_TEST_DBDRIVER and EVEGO_TEST_DBPATH environment variables as appropriate.

License

Portions of the EVE static data export are included in this repository (testdb.sqlite); the following notice applies to that file:

© 2014 CCP hf. All rights reserved. "EVE", "EVE Online", "CCP", and all related logos and images are trademarks or registered trademarks of CCP hf.

The remainder of this repository is © 2014 Brad Ackerman and licensed under the Apache License 2.0, the full text of which is in the LICENSE file.

Documentation

Overview

Package evego provides an interface to the EVE Online static data export and APIs.

For an example program that uses this library, see the cmd/evego package.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func SortSkills 

func SortSkills(skills []Skill)

SortSkills sorts the provided skill array by group and name.

Types

type ActivityType 

type ActivityType int

ActivityType is an industrial activity performed on or resulting in a blueprint. 

const (
	None ActivityType = iota
	Manufacturing
	ResearchingTechnology
	ResearchingTE
	ResearchingME
	Copying
	Duplicating
	ReverseEngineering
	Invention
)

The ActivityType values.

func (ActivityType) String 

func (i ActivityType) String() string

type BlueprintItem 

type BlueprintItem struct {
	// ItemID is a unique identifier for this object.
	ItemID int `xml:"itemID,attr"`
	// LocationID is the solar system, station, or container ID where an object is located.
	LocationID int `xml:"locationID,attr"`
	// StationID is the solar system, station, or outpost ID where an object is located.
	StationID int `xml:"-"`
	// TypeID is the item's type.
	TypeID int `xml:"typeID,attr"`
	// TypeName is the item's type name.
	TypeName string `xml:"typeName,attr"`
	// Quantity is the number of items in this stack, or -1 if it's not stacked.
	Quantity int `xml:"quantity,attr"`
	// Flag indicates the item's position; see the InventoryFlag enum.
	Flag InventoryFlag `xml:"flagID,attr"`
	// TimeEfficiency is the blueprint's researched time efficiency level [0..20]
	TimeEfficiency int `xml:"timeEfficiency,attr"`
	// MaterialEfficiency is the blueprint's researched material efficiency level [0..10]
	MaterialEfficiency int `xml:"materialEfficiency,attr"`
	// NumRuns is the number of runs remaining (-1 for original blueprints)
	NumRuns int `xml:"runs,attr"`
	// IsOriginal is true iff this blueprint is an original.
	IsOriginal bool `xml:"-"`
}

BlueprintItem is a blueprint returned from a blueprint endpoint.

type BlueprintType 

type BlueprintType int

BlueprintType is a blueprint's original/copy status. 

const (
	// NotBlueprint is not a blueprint.
	NotBlueprint BlueprintType = 0
	// BlueprintOriginal is an orignal blueprint.
	BlueprintOriginal BlueprintType = -1
	// BlueprintCopy is a blueprint copy.
	BlueprintCopy BlueprintType = -2
)

func (BlueprintType) String 

func (i BlueprintType) String() string

type Cache 

type Cache interface {
	io.Closer

	// Get returns the cached value of the key, if it is available and unexpired.
	// It also returns a boolean flag that is true if there was a hit, and false
	// if the item was not in the cache or it was expired.
	Get(key string) ([]byte, bool)

	// Put takes a key and blob to persist in the cache, and the item's expiry
	// time. It returns an error if something has gone wrong with the cache,
	// or nil otherwise.
	Put(key string, val []byte, expires time.Time) error
}

Cache is the interface expected by evego packages for a local cache.

type Character 

type Character struct {
	Name          string `json:"name"          xml:"name,attr"`
	ID            int    `json:"id"            xml:"characterID,attr"`
	Corporation   string `json:"corporation"   xml:"corporationName,attr"`
	CorporationID int    `json:"corporationID" xml:"corporationID,attr"`
	Alliance      string `json:"alliance"      xml:"allianceName,attr"`
	AllianceID    int    `json:"allianceID"    xml:"allianceID,attr"`
}

Character represents one EVE player toon.

type CharacterSheet 

type CharacterSheet struct {
	Character
	Skills []Skill `json:"skills"`
}

CharacterSheet contains the character sheet information for a toon as provied by the /char/CharacterSheet.xml.aspx endpoint.

type Database 

type Database interface {
	io.Closer

	ItemForName(itemName string) (*Item, error)
	ItemForID(itemID int) (*Item, error)
	ItemsForIDs(itemIDs []int) ([]*Item, error)
	ItemComposition(itemID int) ([]InventoryLine, error)
	MarketGroupForItem(item *Item) (*MarketGroup, error)

	SolarSystemForID(systemID int) (*SolarSystem, error)
	SolarSystemForName(systemName string) (*SolarSystem, error)
	SolarSystemsForPattern(systemName string) ([]SolarSystem, error)

	RegionForName(regionName string) (*Region, error)
	StationForID(stationID int) (*Station, error)
	StationsForName(stationName string) ([]Station, error)

	// BlueprintOutputs returns the items and quantity of each that can be output
	// by performing industrial actions on a blueprint given that blueprint's name
	// (typeName) as a string. The type name may include the percent (%) character
	// as a wildcard.
	BlueprintOutputs(typeName string) ([]IndustryActivity, error)

	// BlueprintForProduct returns the blueprints that can produce a given output.
	BlueprintForProduct(typeName string) ([]IndustryActivity, error)

	// BlueprintsUsingMaterial returns the blueprints that use the given input material
	// in an industrial process (manufacturing, invention, etc.)
	BlueprintsUsingMaterial(typeName string) ([]IndustryActivity, error)

	// BlueprintProductionInputs returns the required materials for one run
	// of production on an unresearched (ME 0% / TE 0%) blueprint. It takes as
	// parameters the blueprint to be used and the selected output product.
	BlueprintProductionInputs(
		typeName string, outputTypeName string) ([]InventoryLine, error)

	// ReprocessOutputMaterials produces a list of all materials that are possible
	// outputs from reprocessing.
	ReprocessOutputMaterials() ([]Item, error)
}

Database is an object that returns information about items in EVE.

type IndustryActivity 

type IndustryActivity struct {
	InputItem      *Item
	ActivityType   ActivityType
	OutputItem     *Item
	OutputQuantity int
}

IndustryActivity is an action (e.g. invention) taken on an input item (e.g. Vexor Blueprint) producing a result (e.g. Ishtar Blueprint).

func (IndustryActivity) String 

func (i IndustryActivity) String() string

type InventoryFlag 

type InventoryFlag int

InventoryFlag describes the location of an item in the asset list. 

const (
	// InvNone : None
	InvNone InventoryFlag = 0
	// InvWallet : Wallet
	InvWallet InventoryFlag = 1
	// InvFactory : Factory
	InvFactory InventoryFlag = 2
	// InvWardrobe : Wardrobe
	InvWardrobe InventoryFlag = 3
	// InvHangar : Hangar
	InvHangar InventoryFlag = 4
	// InvCargo : Cargo
	InvCargo InventoryFlag = 5
	// InvBriefcase : Briefcase
	InvBriefcase InventoryFlag = 6
	// InvSkill : Skill
	InvSkill InventoryFlag = 7
	// InvReward : Reward
	InvReward InventoryFlag = 8
	// InvConnected : Character in station connected
	InvConnected InventoryFlag = 9
	// InvDisconnected : Character in station offline
	InvDisconnected InventoryFlag = 10
	// InvLoSlot0 : Low power slot 1
	InvLoSlot0 InventoryFlag = 11
	// InvLoSlot1 : Low power slot 2
	InvLoSlot1 InventoryFlag = 12
	// InvLoSlot2 : Low power slot 3
	InvLoSlot2 InventoryFlag = 13
	// InvLoSlot3 : Low power slot 4
	InvLoSlot3 InventoryFlag = 14
	// InvLoSlot4 : Low power slot 5
	InvLoSlot4 InventoryFlag = 15
	// InvLoSlot5 : Low power slot 6
	InvLoSlot5 InventoryFlag = 16
	// InvLoSlot6 : Low power slot 7
	InvLoSlot6 InventoryFlag = 17
	// InvLoSlot7 : Low power slot 8
	InvLoSlot7 InventoryFlag = 18
	// InvMedSlot0 : Medium power slot 1
	InvMedSlot0 InventoryFlag = 19
	// InvMedSlot1 : Medium power slot 2
	InvMedSlot1 InventoryFlag = 20
	// InvMedSlot2 : Medium power slot 3
	InvMedSlot2 InventoryFlag = 21
	// InvMedSlot3 : Medium power slot 4
	InvMedSlot3 InventoryFlag = 22
	// InvMedSlot4 : Medium power slot 5
	InvMedSlot4 InventoryFlag = 23
	// InvMedSlot5 : Medium power slot 6
	InvMedSlot5 InventoryFlag = 24
	// InvMedSlot6 : Medium power slot 7
	InvMedSlot6 InventoryFlag = 25
	// InvMedSlot7 : Medium power slot 8
	InvMedSlot7 InventoryFlag = 26
	// InvHiSlot0 : High power slot 1
	InvHiSlot0 InventoryFlag = 27
	// InvHiSlot1 : High power slot 2
	InvHiSlot1 InventoryFlag = 28
	// InvHiSlot2 : High power slot 3
	InvHiSlot2 InventoryFlag = 29
	// InvHiSlot3 : High power slot 4
	InvHiSlot3 InventoryFlag = 30
	// InvHiSlot4 : High power slot 5
	InvHiSlot4 InventoryFlag = 31
	// InvHiSlot5 : High power slot 6
	InvHiSlot5 InventoryFlag = 32
	// InvHiSlot6 : High power slot 7
	InvHiSlot6 InventoryFlag = 33
	// InvHiSlot7 : High power slot 8
	InvHiSlot7 InventoryFlag = 34
	// InvFixedSlot : Fixed Slot
	InvFixedSlot InventoryFlag = 35
	// InvPromenadeSlot1 : Promenade Slot 1
	InvPromenadeSlot1 InventoryFlag = 40
	// InvPromenadeSlot2 : Promenade Slot 2
	InvPromenadeSlot2 InventoryFlag = 41
	// InvPromenadeSlot3 : Promenade Slot 3
	InvPromenadeSlot3 InventoryFlag = 42
	// InvPromenadeSlot4 : Promenade Slot 4
	InvPromenadeSlot4 InventoryFlag = 43
	// InvPromenadeSlot5 : Promenade Slot 5
	InvPromenadeSlot5 InventoryFlag = 44
	// InvPromenadeSlot6 : Promenade Slot 6
	InvPromenadeSlot6 InventoryFlag = 45
	// InvPromenadeSlot7 : Promenade Slot 7
	InvPromenadeSlot7 InventoryFlag = 46
	// InvPromenadeSlot8 : Promenade Slot 8
	InvPromenadeSlot8 InventoryFlag = 47
	// InvPromenadeSlot9 : Promenade Slot 9
	InvPromenadeSlot9 InventoryFlag = 48
	// InvPromenadeSlot10 : Promenade Slot 10
	InvPromenadeSlot10 InventoryFlag = 49
	// InvPromenadeSlot11 : Promenade Slot 11
	InvPromenadeSlot11 InventoryFlag = 50
	// InvPromenadeSlot12 : Promenade Slot 12
	InvPromenadeSlot12 InventoryFlag = 51
	// InvPromenadeSlot13 : Promenade Slot 13
	InvPromenadeSlot13 InventoryFlag = 52
	// InvPromenadeSlot14 : Promenade Slot 14
	InvPromenadeSlot14 InventoryFlag = 53
	// InvPromenadeSlot15 : Promenade Slot 15
	InvPromenadeSlot15 InventoryFlag = 54
	// InvPromenadeSlot16 : Promenade Slot 16
	InvPromenadeSlot16 InventoryFlag = 55
	// InvCapsule : Capsule
	InvCapsule InventoryFlag = 56
	// InvPilot : Pilot
	InvPilot InventoryFlag = 57
	// InvPassenger : Passenger
	InvPassenger InventoryFlag = 58
	// InvBoardingGate : Boarding gate
	InvBoardingGate InventoryFlag = 59
	// InvCrew : Crew
	InvCrew InventoryFlag = 60
	// InvSkillInTraining : Skill in training
	InvSkillInTraining InventoryFlag = 61
	// InvCorpMarket : Corporation Market Deliveries / Returns
	InvCorpMarket InventoryFlag = 62
	// InvLocked : Locked item, can not be moved unless unlocked
	InvLocked InventoryFlag = 63
	// InvUnlocked : Unlocked item, can be moved
	InvUnlocked InventoryFlag = 64
	// InvOfficeSlot1 : Office slot 1
	InvOfficeSlot1 InventoryFlag = 70
	// InvOfficeSlot2 : Office slot 2
	InvOfficeSlot2 InventoryFlag = 71
	// InvOfficeSlot3 : Office slot 3
	InvOfficeSlot3 InventoryFlag = 72
	// InvOfficeSlot4 : Office slot 4
	InvOfficeSlot4 InventoryFlag = 73
	// InvOfficeSlot5 : Office slot 5
	InvOfficeSlot5 InventoryFlag = 74
	// InvOfficeSlot6 : Office slot 6
	InvOfficeSlot6 InventoryFlag = 75
	// InvOfficeSlot7 : Office slot 7
	InvOfficeSlot7 InventoryFlag = 76
	// InvOfficeSlot8 : Office slot 8
	InvOfficeSlot8 InventoryFlag = 77
	// InvOfficeSlot9 : Office slot 9
	InvOfficeSlot9 InventoryFlag = 78
	// InvOfficeSlot10 : Office slot 10
	InvOfficeSlot10 InventoryFlag = 79
	// InvOfficeSlot11 : Office slot 11
	InvOfficeSlot11 InventoryFlag = 80
	// InvOfficeSlot12 : Office slot 12
	InvOfficeSlot12 InventoryFlag = 81
	// InvOfficeSlot13 : Office slot 13
	InvOfficeSlot13 InventoryFlag = 82
	// InvOfficeSlot14 : Office slot 14
	InvOfficeSlot14 InventoryFlag = 83
	// InvOfficeSlot15 : Office slot 15
	InvOfficeSlot15 InventoryFlag = 84
	// InvOfficeSlot16 : Office slot 16
	InvOfficeSlot16 InventoryFlag = 85
	// InvBonus : Bonus
	InvBonus InventoryFlag = 86
	// InvDroneBay : Drone Bay
	InvDroneBay InventoryFlag = 87
	// InvBooster : Booster
	InvBooster InventoryFlag = 88
	// InvImplant : Implant
	InvImplant InventoryFlag = 89
	// InvShipHangar : Ship Hangar
	InvShipHangar InventoryFlag = 90
	// InvShipOffline : Ship Offline
	InvShipOffline InventoryFlag = 91
	// InvRigSlot0 : Rig power slot 1
	InvRigSlot0 InventoryFlag = 92
	// InvRigSlot1 : Rig power slot 2
	InvRigSlot1 InventoryFlag = 93
	// InvRigSlot2 : Rig power slot 3
	InvRigSlot2 InventoryFlag = 94
	// InvRigSlot3 : Rig power slot 4
	InvRigSlot3 InventoryFlag = 95
	// InvRigSlot4 : Rig power slot 5
	InvRigSlot4 InventoryFlag = 96
	// InvRigSlot5 : Rig power slot 6
	InvRigSlot5 InventoryFlag = 97
	// InvRigSlot6 : Rig power slot 7
	InvRigSlot6 InventoryFlag = 98
	// InvRigSlot7 : Rig power slot 8
	InvRigSlot7 InventoryFlag = 99
	// InvFactoryOperation : Factory Background Operation
	InvFactoryOperation InventoryFlag = 100
	// InvCorpSAG2 : Corp Security Access Group 2
	InvCorpSAG2 InventoryFlag = 116
	// InvCorpSAG3 : Corp Security Access Group 3
	InvCorpSAG3 InventoryFlag = 117
	// InvCorpSAG4 : Corp Security Access Group 4
	InvCorpSAG4 InventoryFlag = 118
	// InvCorpSAG5 : Corp Security Access Group 5
	InvCorpSAG5 InventoryFlag = 119
	// InvCorpSAG6 : Corp Security Access Group 6
	InvCorpSAG6 InventoryFlag = 120
	// InvCorpSAG7 : Corp Security Access Group 7
	InvCorpSAG7 InventoryFlag = 121
	// InvSecondaryStorage : Secondary Storage
	InvSecondaryStorage InventoryFlag = 122
	// InvCaptainsQuarters : Captains Quarters
	InvCaptainsQuarters InventoryFlag = 123
	// InvWisPromenade : Wis Promenade
	InvWisPromenade InventoryFlag = 124
	// InvSubSystem0 : Sub system slot 0
	InvSubSystem0 InventoryFlag = 125
	// InvSubSystem1 : Sub system slot 1
	InvSubSystem1 InventoryFlag = 126
	// InvSubSystem2 : Sub system slot 2
	InvSubSystem2 InventoryFlag = 127
	// InvSubSystem3 : Sub system slot 3
	InvSubSystem3 InventoryFlag = 128
	// InvSubSystem4 : Sub system slot 4
	InvSubSystem4 InventoryFlag = 129
	// InvSubSystem5 : Sub system slot 5
	InvSubSystem5 InventoryFlag = 130
	// InvSubSystem6 : Sub system slot 6
	InvSubSystem6 InventoryFlag = 131
	// InvSubSystem7 : Sub system slot 7
	InvSubSystem7 InventoryFlag = 132
	// InvSpecializedFuelBay : Specialized Fuel Bay
	InvSpecializedFuelBay InventoryFlag = 133
	// InvSpecializedOreHold : Specialized Ore Hold
	InvSpecializedOreHold InventoryFlag = 134
	// InvSpecializedGasHold : Specialized Gas Hold
	InvSpecializedGasHold InventoryFlag = 135
	// InvSpecializedMineralHold : Specialized Mineral Hold
	InvSpecializedMineralHold InventoryFlag = 136
	// InvSpecializedSalvageHold : Specialized Salvage Hold
	InvSpecializedSalvageHold InventoryFlag = 137
	// InvSpecializedShipHold : Specialized Ship Hold
	InvSpecializedShipHold InventoryFlag = 138
	// InvSpecializedSmallShipHold : Specialized Small Ship Hold
	InvSpecializedSmallShipHold InventoryFlag = 139
	// InvSpecializedMediumShipHold : Specialized Medium Ship Hold
	InvSpecializedMediumShipHold InventoryFlag = 140
	// InvSpecializedLargeShipHold : Specialized Large Ship Hold
	InvSpecializedLargeShipHold InventoryFlag = 141
	// InvSpecializedIndustrialShipHold : Specialized Industrial Ship Hold
	InvSpecializedIndustrialShipHold InventoryFlag = 142
	// InvSpecializedAmmoHold : Specialized Ammo Hold
	InvSpecializedAmmoHold InventoryFlag = 143
	// InvStructureActive : StructureActive
	InvStructureActive InventoryFlag = 144
	// InvStructureInactive : StructureInactive
	InvStructureInactive InventoryFlag = 145
	// InvJunkyardReprocessed : This item was put into a junkyard through reprocession.
	InvJunkyardReprocessed InventoryFlag = 146
	// InvJunkyardTrashed : This item was put into a junkyard through being trashed by its owner.
	InvJunkyardTrashed InventoryFlag = 147
	// InvSpecializedCommandCenterHold : Specialized Command Center Hold
	InvSpecializedCommandCenterHold InventoryFlag = 148
	// InvSpecializedPlanetaryCommoditiesHold : Specialized Planetary Commodities Hold
	InvSpecializedPlanetaryCommoditiesHold InventoryFlag = 149
	// InvPlanetSurface : Planet Surface
	InvPlanetSurface InventoryFlag = 150
	// InvSpecializedMaterialBay : Specialized Material Bay
	InvSpecializedMaterialBay InventoryFlag = 151
	// InvDustCharacterDatabank : Dust Character Databank
	InvDustCharacterDatabank InventoryFlag = 152
	// InvDustCharacterBattle : Dust Character Battle
	InvDustCharacterBattle InventoryFlag = 153
	// InvQuafeBay : Quafe Bay
	InvQuafeBay InventoryFlag = 154
	// InvFleetHangar : Fleet Hangar
	InvFleetHangar InventoryFlag = 155
	// InvHiddenModifiers : Hidden Modifiers
	InvHiddenModifiers InventoryFlag = 156
)

func (InventoryFlag) String 

func (i InventoryFlag) String() string

type InventoryItem 

type InventoryItem struct {
	// ItemID is a unique identifier for this object.
	ItemID int `xml:"itemID,attr"`
	// StationID is the solar system or station where an object is located.
	StationID int `xml:"locationID,attr"`
	// TypeID is the item's type.
	TypeID int `xml:"typeID,attr"`
	// Quantity is the number of items in this stack.
	Quantity int `xml:"quantity,attr"`
	// BlueprintType is the type of blueprint (original or copy), if applicable.
	BlueprintType BlueprintType `xml:"rawQuantity,attr"`
	// Unpackaged is true iff the item is unpackaged.
	Unpackaged bool `xml:"singleton,attr"`
	// Flag indicates the item's position; see the InventoryFlag enum.
	Flag InventoryFlag `xml:"flag,attr"`
	// Contents is a list of items that this item contains, if any.
	Contents []InventoryItem `xml:"rowset>row"`
}

InventoryItem is exactly what it sounds like.

type InventoryLine 

type InventoryLine struct {
	Quantity int
	Item     *Item
}

InventoryLine is an item in a material's composition, the player's inventory, or whatever.

func (InventoryLine) String 

func (i InventoryLine) String() string

type Item 

type Item struct {
	Name      string `db:"typeName"`
	ID        int    `db:"typeID"`
	Type      ItemType
	Category  string `db:"categoryName"` // e.g. Module, Drone, Charge
	Group     string `db:"groupName"`    // e.g. Omber, Logistic Drone, Footwear
	GroupID   int    `db:"groupID"`
	BatchSize int    `db:"portionSize"`
}

Item is an Eve item.

func (Item) String 

func (i Item) String() string

type ItemType 

type ItemType int

ItemType is the type of an Eve item, and is used chiefly for correctly determining the item's reprocessing rate. 

const (
	UnknownItemType ItemType = iota
	Ore
	Ice
	Other
)

ItemType is the type of an Eve item.

func (ItemType) String 

func (i ItemType) String() string

type Market 

type Market interface {
	io.Closer

	// OrdersForItem returns the market orders for a given item.
	// location is the name of either a system or a region.
	// type can be Buy, Sell, or All.
	OrdersForItem(itemID *Item, location string, orderType OrderType) (*[]Order, error)

	// BuyInStation returns the buy orders that are in range of the given
	// station (i.e., can be sold to by a user there).
	BuyInStation(itemID *Item, location *Station) (*[]Order, error)

	// OrdersInStation returns the buy orders that are in range of a given station,
	// and the sell orders available at that station.
	OrdersInStation(item *Item, location *Station) (*[]Order, error)
}

Market returns information about market orders.

type MarketGroup 

type MarketGroup struct {
	ID          int
	Parent      *MarketGroup
	Name        string
	Description string
}

MarketGroup is a group of items in the EVE market.

func (MarketGroup) String 

func (m MarketGroup) String() string

type Order 

type Order struct {
	Type       OrderType
	Item       *Item
	Quantity   int
	Price      float64
	Station    *Station
	Expiration time.Time

	MinQuantity int
	JumpRange   OrderRange
	NumJumps    int
}

Order represents an order on the EVE market.

func (*Order) String 

func (o *Order) String() string

type OrderRange 

type OrderRange int

OrderRange is the area from which capsuleers can sell to a buy order. 

const (
	// BuyStation is only the order's station.
	BuyStation OrderRange = iota
	// BuySystem is any station in the order's system.
	BuySystem
	// BuyNumberJumps is a specified number of jumps from the order's system.
	BuyNumberJumps
	// BuyRegion is anywhere within the order's region.
	BuyRegion
)

func (OrderRange) String 

func (i OrderRange) String() string

type OrderType 

type OrderType int

OrderType is the order's type (either buy or sell); or All for searching for either 

const (
	// Buy order
	Buy OrderType = iota
	// Sell order
	Sell
	// AllOrders is either buy or sell (used for searches only)
	AllOrders
)

func (OrderType) String 

func (i OrderType) String() string

type Region 

type Region struct {
	Name string `db:"regionName"`
	ID   int    `db:"regionID"`
}

Region is one of the regions in the EVE universe.

type Router 

type Router interface {
	io.Closer
	// NumJumps returns the number of jumps in the shortest path from
	// fromSystem to toSystem, or -1 if the destination is unreachable
	// from the start.
	NumJumps(fromSystem, toSystem *SolarSystem) (int, error)

	// NumJumpsID is a convenience method for NumJumps. Or is it the reverse?
	NumJumpsID(fromSystemID, toSystemID int) (int, error)
}

Router is the interface for the backing service that provides a router.

type Skill 

type Skill struct {
	Name           string `json:"name"`
	Group          string `json:"group"`
	GroupID        int    `json:"groupID"`
	TypeID         int    `json:"typeID"         xml:"typeID,attr"`
	NumSkillpoints int    `json:"numSkillpoints" xml:"skillpoints,attr"`
	Level          int    `json:"level"          xml:"level,attr"`
	Published      bool   `json:"isPublished"    xml:"published,attr"`
}

Skill is one of a character's injected skills.

type SolarSystem 

type SolarSystem struct {
	Name            string `db:"solarSystemName"`
	ID              int    `db:"solarSystemID"`
	Constellation   string `db:"constellationName"`
	ConstellationID int    `db:"constellationID"`
	Region          string `db:"regionName"`
	RegionID        int    `db:"regionID"`
	Security        float64
}

SolarSystem is a solar system within the EVE universe.

type Standing 

type Standing struct {
	EntityType StandingType
	ID         int     `xml:"fromID,attr"`
	Name       string  `xml:"fromName,attr"`
	Standing   float64 `xml:"standing,attr"`
}

Standing is a standing level from a specified entity.

type StandingType 

type StandingType int

StandingType is the type of entity with which a Standing applies. 

const (
	UnknownEntity StandingType = iota
	NPCFaction
	NPCCorporation
	NPCAgent
	PlayerCharacter
	PlayerCorporation
	PlayerAlliance
)

StandingType is the type of entity with which a Standing applies.

func (StandingType) String 

func (i StandingType) String() string

type Station 

type Station struct {
	Name                   string  `db:"stationName"`
	ID                     int     `db:"stationID"`
	SystemID               int     `db:"solarSystemID"`
	ConstellationID        int     `db:"constellationID"`
	RegionID               int     `db:"regionID"`
	CorporationID          int     `db:"corporationID"`
	Corporation            string  `db:"corporationName"`
	ReprocessingEfficiency float64 `db:"reprocessingEfficiency"`
}

Station is either an NPC station or a conquerable outpost.

type XMLAPI 

type XMLAPI interface {
	io.Closer

	// OutpostForID returns a conquerable station with the provided ID.
	OutpostForID(id int) (*Station, error)

	// OutpostsForName returns the stations matching the provided name pattern.
	// The percent character (%) may be used as a wildcard.
	OutpostsForName(name string) ([]Station, error)

	// DumpOutposts returns the current list of outposts.
	DumpOutposts() []*Station

	// AccountCharacters returns a list of characters that the provided key can
	// access.
	AccountCharacters(key *XMLKey) ([]Character, error)

	// CharacterSheet returns the character sheet for the given character ID.
	CharacterSheet(key *XMLKey, characterID int) (*CharacterSheet, error)

	// CharacterStandings returns a character's standings.
	CharacterStandings(key *XMLKey, characterID int) ([]Standing, error)

	// Assets gets a character's assets.
	Assets(key *XMLKey, characterID int) ([]InventoryItem, error)

	// Blueprints gets a character's blueprints.
	Blueprints(key *XMLKey, characterID int, assets []InventoryItem) ([]BlueprintItem, error)
}

XMLAPI is an interface to the EVE XML API. We could make the interface sufficiently abstract to cover multiple APIs, but that seems on the silly side.

type XMLKey 

type XMLKey struct {
	KeyID            int
	VerificationCode string
	// Description is an optional description provided by the user.
	Description string
}

XMLKey is a key ID / verification code pair used to retrieve data from the EVE XML API.

Source Files

View all Source files

Directories

Path Synopsis
cmd
eve
pkg
cache
Package cache provides sample implementations of a cache handler for evego.
 Package cache provides sample implementations of a cache handler for evego.
character
Package character provides calculation of character statistics.
 Package character provides calculation of character statistics.
dbaccess
eveapi
Package eveapi is the public interface for accessing the EVE APIs (XML, CREST, or whatever.) Package eveapi is the public interface for accessing the EVE APIs (XML, CREST, or whatever.)
 Package eveapi is the public interface for accessing the EVE APIs (XML, CREST, or whatever.) Package eveapi is the public interface for accessing the EVE APIs (XML, CREST, or whatever.)
evesso
Package evesso provides support for EVE's single sign-on API.
 Package evesso provides support for EVE's single sign-on API.
industry
Package industry calculates the output from manufacturing, reprocessing, and other industrial processes.
 Package industry calculates the output from manufacturing, reprocessing, and other industrial processes.
market
parsing
Package parsing extracts useful data from external input (EFT, copy-and-paste from the game client, etc.)
 Package parsing extracts useful data from external input (EFT, copy-and-paste from the game client, etc.)
routing
Package routing provides services to calculate paths between points in EVE.
 Package routing provides services to calculate paths between points in EVE.
test
Package test provides useful extensions to goconvey.
 Package test provides useful extensions to goconvey.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.