|
Home >
ICS
>
Participants >
Dragos > TRITON Configuration
|
Dragos Configuration
Product Versions
- Dragos Platform SiteStore version: 7.2
- Dragos Platform Sensor version: 7.2
- Dragos Knowledge Pack: April 2020
Description
The Dragos Platform is a network-based cybersecurity software technology that identifies ICS network assets and their communications to provide an inventory and topology, identify and manage vulnerabilities, detect malicious activity, and provides guidance to investigate incidents. Within the Dragos Platform, we leverage The 4 Types of Threat Detection model.
The 4 Types of Threat Detection create different use-cases and detection strategies for defenders leveraging the Dragos Platform and are aggregated in the Notification view.
-
Modeling Modeling is a mathematical approach to detecting threats by defining “normal” and measuring the divergence from the definition. When organizations talk about “baselines”, “machine learning” or various forms of “anomaly detection” they are referring to Modeling based detections. The goal of Modeling is to build profiles of the environment over time and alert on uncustomary behaviors. The value in doing this approach is that it is threat-agnostic instead of relying on knowledge of the environment. The downside is that detections contain very limited if any context on the threat because the detection was not looking for the threat itself but the deviation. These detections are great for hunting but not ideal for triaging as their threat context is specific to the modeled environment.
-
Configuration Configuration-based detection relies on current knowledge of an environment’s known architecture or design to identify changes to the configuration. As an example, a new device would be a change to the configuration. However, a change in the configuration such as a change on the timing in a GPS clock, a project file upload to a programmable logic controller (PLC), or the change of a key switch from RUN mode to PROGRAM mode in a safety system would all be configuration alerts. These alerts can be useful for understanding your environment better and provide good forensics on changes in the environment but contain little threat context for triaging.
-
Indicators Indicators are the quickest way of leveraging detection with threat context. When properly created, indicators identify specific activity that gives analysts the context to properly prioritize and respond to the activity observed. There are two main benefits associated with indicators: knowledge enrichment and quick scoping. The downside is that adversaries can change their dependence on specific indicators (such as infrastructure and malware), which can quickly make those specific indicators ineffective. Indicators though are ideal for triaging for known threats.
-
Threat Behavior Threat behavior analytics codify malicious adversary tradecraft (e.g., tactics, techniques, and methods) for detection regardless of specific indicators like malware or infrastructure. Threat behavior analytics are the best form of expandable and alterable threat detection that also result in context for the defender. The downside is they are often time-intensive to create. The value is that they are not tied to any individual adversary but instead represent a series of events that catch known tactics and techniques that adversaries leverage making them able to identify known and unknown threat groups with context making them a great form of threat detection. The structure of MITRE ATT&CK is based upon Threat Behaviors and documents Threat Behaviors in detail, which is why it is such a valuable resource for network defenders.
Hunting for threat behavior is akin to “finding a needle in a haystack” of data. To best approach this monumental task, the Dragos Platform sorted the haystack into smaller, more manageable haystacks. These smaller haystacks make it easier for Dragos Platform users to identify and investigate threat behavior within ICS Networks. The smaller haystacks consist of the following:
Tagged Data |
Data that the Dragos Platform might be interested in using for the creation of Events and Notifications is identified, inspected using deep packet analysis, and then stored as Tagged Data. |
Events |
Events (Severity 0) are actions taken within the ICS network that you probably want to keep track of but do not necessarily want to be constantly notified about. Events could be atomic (single step) threat behaviors in the context of an attack but could also be normal operations of an ICS environment. Events are normally hidden from view but can feed information into Composite Analytics (see below) or turned on to see the Events that led up to high severity Notifications. They are also useful for forensics and investigation timelines. |
Notifications |
Notifications are actions taken within the ICS network that could be considered one of The 4 Types of Threat Detection. The higher the severity rating of the Notification, the higher the confidence that this is a real threat, and that action should be taken. |
Composite Analytics |
Composite Analytics are multi-step threat analytics that more confidently relate to adversary actions. They often will take data from multiple sources, such as Windows Events, Network Traffic, Asset Information, or Vulnerability Information to create context-sensitive, high confidence and high severity Notifications (often severity 3 – 5). |
Query Focused Datasets (QFDs) |
Query Focused Datasets (QFDs) provide analysts with powerful tools for both proactive threat hunts and investigations. A query focused dataset is a pared down dataset that combines disparate data to enable analysts to prove or disprove a given hypothesis quickly. While a QFD is a subset of a larger dataset, the QFD might contain additional enriched information that provides analysts with an optimized view of the situation in question. QFDs normalize data and reduce the overall time analysts must spend when triaging suspicious activity or threat hunting. |
Product Configuration
Each of the Windows hosts used the Microsoft Sysmon tool and forwarded logs to the Dragos Platform which can passively collect network data off of the environment and optionally leverage host-based logs. The network traffic was monitored by one Dragos network sensor monitoring the SPAN port of the switch. With this deployment, Windows host and network data were our two data sources.
Dragos Platform Configuration
- Network Traffic Ingestion by Dragos Sensor
- Endpoint Windows Event Collection using SYSMON and Winlogbeat
- Windows Events ingested using the SYSLOG via Dragos Platform Sitestore


If you want to be the best, you have to learn from the best. At Tuts+ we believe in getting the best to share their skills and techniques.
We offer sites on a range of creative niches including Photoshop and Graphics, Vectors and Illustration, Web Development and Design, Motion Graphics, Flash and ActionScript, Computer Graphics, Photography and Audio Production. Select a site from the Our Sites navigation above.


uAdmin Tutorial Part 2 - Internal vs. External Models¶
In this part, we will discuss about the difference between internal and external models, and how to crop images in the model.
Internal Models¶
Internal models are models inside your main.go and don’t have their .go file, they are useful if you want to make something quick but it is advisable to always you external models.
The code below is an example of internal model:
package main
import (
"time"
"github.com/username/todo/models"
"github.com/uadmin/uadmin"
)
// Todo internal model ...
type Todo struct {
uadmin.Model
Name string
Description string `uadmin:"html"`
TargetDate time.Time
Progress int `uadmin:"progress_bar"`
}
func main() {
uadmin.Register(
Todo{}, // register the Todo struct
models.Category{},
)
uadmin.StartServer()
}
External Models¶
External models are models outside of main.go and have their own .go file. Let’s add a category external model, create a file named category.go and add the following code:
package models
import "github.com/uadmin/uadmin"
// Category model ...
type Category struct {
uadmin.Model
Name string `uadmin:"required"`
Icon string `uadmin:"image"`
}
Now register the model on main.go where models is folder name and Category is model/struct name:
func main() {
uadmin.Register(
Todo{},
models.Category{}, // <-- place it here
)
uadmin.StartServer()
}
Run your application. As expected, the category model is added in the uAdmin Dashboard.
Let’s create a new data in the category model.
As you can see, the Name field is required indicated by the * symbol. Required field cannot be an empty string. In the Icon field, you can browse an image file in .png, .jpg, .jpeg, or .gif in your computer.
uAdmin also allows you to crop your images.
Once you are done, click the Crop button below and refresh the webpage to save your progress.
Congrats, you know now how to create an external model, adding a new data in the model through the server and cropping an image.
In the next part we will talk about linking models using a foreign key.


Home
Trees
Indices
Help
pystroke
[
hide private
]
[
frames
] |
no frames
]
Identifier Index
[
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W X
Y
Z
_
]
A
ACTIVEEVENT
(in
pystroke.draw_engine
)
AUDIO_S16LSB
(in
pystroke.draw_engine
)
AUDIO_U16
(in
pystroke.hud
)
ACTIVEEVENT
(in
pystroke.event_engine
)
AUDIO_S16LSB
(in
pystroke.event_engine
)
AUDIO_U16
(in
pystroke.input_engine
)
ACTIVEEVENT
(in
pystroke.game_engine
)
AUDIO_S16LSB
(in
pystroke.game_engine
)
AUDIO_U16
(in
pystroke.vex
)
ACTIVEEVENT
(in
pystroke.hud
)
AUDIO_S16LSB
(in
pystroke.hud
)
AUDIO_U16LSB
(in
pystroke.draw_engine
)
ACTIVEEVENT
(in
pystroke.input_engine
)
AUDIO_S16LSB
(in
pystroke.input_engine
)
AUDIO_U16LSB
(in
pystroke.event_engine
)
ACTIVEEVENT
(in
pystroke.vex
)
AUDIO_S16LSB
(in
pystroke.vex
)
AUDIO_U16LSB
(in
pystroke.game_engine
)
add()
(in
HUD
)
AUDIO_S16MSB
(in
pystroke.draw_engine
)
AUDIO_U16LSB
(in
pystroke.hud
)
angle_to_face_point()
(in
Vex
)
AUDIO_S16MSB
(in
pystroke.event_engine
)
AUDIO_U16LSB
(in
pystroke.input_engine
)
ANYFORMAT
(in
pystroke.draw_engine
)
AUDIO_S16MSB
(in
pystroke.game_engine
)
AUDIO_U16LSB
(in
pystroke.vex
)
ANYFORMAT
(in
pystroke.event_engine
)
AUDIO_S16MSB
(in
pystroke.hud
)
AUDIO_U16MSB
(in
pystroke.draw_engine
)
ANYFORMAT
(in
pystroke.game_engine
)
AUDIO_S16MSB
(in
pystroke.input_engine
)
AUDIO_U16MSB
(in
pystroke.event_engine
)
ANYFORMAT
(in
pystroke.hud
)
AUDIO_S16MSB
(in
pystroke.vex
)
AUDIO_U16MSB
(in
pystroke.game_engine
)
ANYFORMAT
(in
pystroke.input_engine
)
AUDIO_S16SYS
(in
pystroke.draw_engine
)
AUDIO_U16MSB
(in
pystroke.hud
)
ANYFORMAT
(in
pystroke.vex
)
AUDIO_S16SYS
(in
pystroke.event_engine
)
AUDIO_U16MSB
(in
pystroke.input_engine
)
AssertionError
AUDIO_S16SYS
(in
pystroke.game_engine
)
AUDIO_U16MSB
(in
pystroke.vex
)
ASYNCBLIT
(in
pystroke.draw_engine
)
AUDIO_S16SYS
(in
pystroke.hud
)
AUDIO_U16SYS
(in
pystroke.draw_engine
)
ASYNCBLIT
(in
pystroke.event_engine
)
AUDIO_S16SYS
(in
pystroke.input_engine
)
AUDIO_U16SYS
(in
pystroke.event_engine
)
ASYNCBLIT
(in
pystroke.game_engine
)
AUDIO_S16SYS
(in
pystroke.vex
)
AUDIO_U16SYS
(in
pystroke.game_engine
)
ASYNCBLIT
(in
pystroke.hud
)
AUDIO_S8
(in
pystroke.draw_engine
)
AUDIO_U16SYS
(in
pystroke.hud
)
ASYNCBLIT
(in
pystroke.input_engine
)
AUDIO_S8
(in
pystroke.event_engine
)
AUDIO_U16SYS
(in
pystroke.input_engine
)
ASYNCBLIT
(in
pystroke.vex
)
AUDIO_S8
(in
pystroke.game_engine
)
AUDIO_U16SYS
(in
pystroke.vex
)
AUDIO_S16
(in
pystroke.draw_engine
)
AUDIO_S8
(in
pystroke.hud
)
AUDIO_U8
(in
pystroke.draw_engine
)
AUDIO_S16
(in
pystroke.event_engine
)
AUDIO_S8
(in
pystroke.input_engine
)
AUDIO_U8
(in
pystroke.event_engine
)
AUDIO_S16
(in
pystroke.game_engine
)
AUDIO_S8
(in
pystroke.vex
)
AUDIO_U8
(in
pystroke.game_engine
)
AUDIO_S16
(in
pystroke.hud
)
AUDIO_U16
(in
pystroke.draw_engine
)
AUDIO_U8
(in
pystroke.hud
)
AUDIO_S16
(in
pystroke.input_engine
)
AUDIO_U16
(in
pystroke.event_engine
)
AUDIO_U8
(in
pystroke.input_engine
)
AUDIO_S16
(in
pystroke.vex
)
AUDIO_U16
(in
pystroke.game_engine
)
AUDIO_U8
(in
pystroke.vex
)
B
begin_draw()
(in
DrawEngine
)
BLEND_RGB_ADD
(in
pystroke.hud
)
BLEND_RGBA_MAX
(in
pystroke.vex
)
behaviour
(in
pystroke
)
BLEND_RGB_ADD
(in
pystroke.input_engine
)
BLEND_RGBA_MIN
(in
pystroke.draw_engine
)
Behaviour
(in
pystroke.behaviour
)
BLEND_RGB_ADD
(in
pystroke.vex
)
BLEND_RGBA_MIN
(in
pystroke.event_engine
)
behaviour_engine
(in
pystroke
)
BLEND_RGB_MAX
(in
pystroke.draw_engine
)
BLEND_RGBA_MIN
(in
pystroke.game_engine
)
BehaviourEngine
(in
pystroke.behaviour_engine
)
BLEND_RGB_MAX
(in
pystroke.event_engine
)
BLEND_RGBA_MIN
(in
pystroke.hud
)
BIG_ENDIAN
(in
pystroke.draw_engine
)
BLEND_RGB_MAX
(in
pystroke.game_engine
)
BLEND_RGBA_MIN
(in
pystroke.input_engine
)
BIG_ENDIAN
(in
pystroke.event_engine
)
BLEND_RGB_MAX
(in
pystroke.hud
)
BLEND_RGBA_MIN
(in
pystroke.vex
)
BIG_ENDIAN
(in
pystroke.game_engine
)
BLEND_RGB_MAX
(in
pystroke.input_engine
)
BLEND_RGBA_MULT
(in
pystroke.draw_engine
)
BIG_ENDIAN
(in
pystroke.hud
)
BLEND_RGB_MAX
(in
pystroke.vex
)
BLEND_RGBA_MULT
(in
pystroke.event_engine
)
BIG_ENDIAN
(in
pystroke.input_engine
)
BLEND_RGB_MIN
(in
pystroke.draw_engine
)
BLEND_RGBA_MULT
(in
pystroke.game_engine
)
BIG_ENDIAN
(in
pystroke.vex
)
BLEND_RGB_MIN
(in
pystroke.event_engine
)
BLEND_RGBA_MULT
(in
pystroke.hud
)
BLEND_ADD
(in
pystroke.draw_engine
)
BLEND_RGB_MIN
(in
pystroke.game_engine
)
BLEND_RGBA_MULT
(in
pystroke.input_engine
)
BLEND_ADD
(in
pystroke.event_engine
)
BLEND_RGB_MIN
(in
pystroke.hud
)
BLEND_RGBA_MULT
(in
pystroke.vex
)
BLEND_ADD
(in
pystroke.game_engine
)
BLEND_RGB_MIN
(in
pystroke.input_engine
)
BLEND_RGBA_SUB
(in
pystroke.draw_engine
)
BLEND_ADD
(in
pystroke.hud
)
BLEND_RGB_MIN
(in
pystroke.vex
)
BLEND_RGBA_SUB
(in
pystroke.event_engine
)
BLEND_ADD
(in
pystroke.input_engine
)
BLEND_RGB_MULT
(in
pystroke.draw_engine
)
BLEND_RGBA_SUB
(in
pystroke.game_engine
)
BLEND_ADD
(in
pystroke.vex
)
BLEND_RGB_MULT
(in
pystroke.event_engine
)
BLEND_RGBA_SUB
(in
pystroke.hud
)
BLEND_MAX
(in
pystroke.draw_engine
)
BLEND_RGB_MULT
(in
pystroke.game_engine
)
BLEND_RGBA_SUB
(in
pystroke.input_engine
)
BLEND_MAX
(in
pystroke.event_engine
)
BLEND_RGB_MULT
(in
pystroke.hud
)
BLEND_RGBA_SUB
(in
pystroke.vex
)
BLEND_MAX
(in
pystroke.game_engine
)
BLEND_RGB_MULT
(in
pystroke.input_engine
)
BLEND_SUB
(in
pystroke.draw_engine
)
BLEND_MAX
(in
pystroke.hud
)
BLEND_RGB_MULT
(in
pystroke.vex
)
BLEND_SUB
(in
pystroke.event_engine
)
BLEND_MAX
(in
pystroke.input_engine
)
BLEND_RGB_SUB
(in
pystroke.draw_engine
)
BLEND_SUB
(in
pystroke.game_engine
)
BLEND_MAX
(in
pystroke.vex
)
BLEND_RGB_SUB
(in
pystroke.event_engine
)
BLEND_SUB
(in
pystroke.hud
)
BLEND_MIN
(in
pystroke.draw_engine
)
BLEND_RGB_SUB
(in
pystroke.game_engine
)
BLEND_SUB
(in
pystroke.input_engine
)
BLEND_MIN
(in
pystroke.event_engine
)
BLEND_RGB_SUB
(in
pystroke.hud
)
BLEND_SUB
(in
pystroke.vex
)
BLEND_MIN
(in
pystroke.game_engine
)
BLEND_RGB_SUB
(in
pystroke.input_engine
)
BUTTON_X1
(in
pystroke.draw_engine
)
BLEND_MIN
(in
pystroke.hud
)
BLEND_RGB_SUB
(in
pystroke.vex
)
BUTTON_X1
(in
pystroke.event_engine
)
BLEND_MIN
(in
pystroke.input_engine
)
BLEND_RGBA_ADD
(in
pystroke.draw_engine
)
BUTTON_X1
(in
pystroke.game_engine
)
BLEND_MIN
(in
pystroke.vex
)
BLEND_RGBA_ADD
(in
pystroke.event_engine
)
BUTTON_X1
(in
pystroke.hud
)
BLEND_MULT
(in
pystroke.draw_engine
)
BLEND_RGBA_ADD
(in
pystroke.game_engine
)
BUTTON_X1
(in
pystroke.input_engine
)
BLEND_MULT
(in
pystroke.event_engine
)
BLEND_RGBA_ADD
(in
pystroke.hud
)
BUTTON_X1
(in
pystroke.vex
)
BLEND_MULT
(in
pystroke.game_engine
)
BLEND_RGBA_ADD
(in
pystroke.input_engine
)
BUTTON_X2
(in
pystroke.draw_engine
)
BLEND_MULT
(in
pystroke.hud
)
BLEND_RGBA_ADD
(in
pystroke.vex
)
BUTTON_X2
(in
pystroke.event_engine
)
BLEND_MULT
(in
pystroke.input_engine
)
BLEND_RGBA_MAX
(in
pystroke.draw_engine
)
BUTTON_X2
(in
pystroke.game_engine
)
BLEND_MULT
(in
pystroke.vex
)
BLEND_RGBA_MAX
(in
pystroke.event_engine
)
BUTTON_X2
(in
pystroke.hud
)
BLEND_RGB_ADD
(in
pystroke.draw_engine
)
BLEND_RGBA_MAX
(in
pystroke.game_engine
)
BUTTON_X2
(in
pystroke.input_engine
)
BLEND_RGB_ADD
(in
pystroke.event_engine
)
BLEND_RGBA_MAX
(in
pystroke.hud
)
BUTTON_X2
(in
pystroke.vex
)
BLEND_RGB_ADD
(in
pystroke.game_engine
)
BLEND_RGBA_MAX
(in
pystroke.input_engine
)
C
clamp()
(in
Vector2
)
CONTINUE_FLAG
(in
pystroke.locals
)
cross_product()
(in
Vector2
)
D
dir_vec()
(in
Vex
)
DOUBLEBUF
(in
pystroke.input_engine
)
draw()
(in
HUDPolygon
)
distance_to()
(in
Vex
)
DOUBLEBUF
(in
pystroke.vex
)
draw()
(in
HUDText
)
dot_product()
(in
Vector2
)
draw()
(in
DrawEngine
)
draw()
(in
Vex
)
DOUBLEBUF
(in
pystroke.draw_engine
)
draw()
(in
GameEngine
)
draw_engine
(in
pystroke
)
DOUBLEBUF
(in
pystroke.event_engine
)
draw()
(in
HUD
)
DrawEngine
(in
pystroke.draw_engine
)
DOUBLEBUF
(in
pystroke.game_engine
)
draw()
(in
HUDElement
)
DOUBLEBUF
(in
pystroke.hud
)
draw()
(in
HUDLine
)
E
end_draw()
(in
DrawEngine
)
event_engine
(in
pystroke
)
EventEngine
(in
pystroke.event_engine
)
F
from_points()
(in
Vector2
)
FULLSCREEN
(in
pystroke.game_engine
)
FULLSCREEN
(in
pystroke.vex
)
FULLSCREEN
(in
pystroke.draw_engine
)
FULLSCREEN
(in
pystroke.hud
)
FULLSCREEN
(in
pystroke.event_engine
)
FULLSCREEN
(in
pystroke.input_engine
)
G
game
(in
pystroke
)
GL_ACCUM_RED_SIZE
(in
pystroke.game_engine
)
GL_GREEN_SIZE
(in
pystroke.input_engine
)
Game
(in
pystroke.game
)
GL_ACCUM_RED_SIZE
(in
pystroke.hud
)
GL_GREEN_SIZE
(in
pystroke.vex
)
game_engine
(in
pystroke
)
GL_ACCUM_RED_SIZE
(in
pystroke.input_engine
)
GL_MULTISAMPLEBUFFERS
(in
pystroke.draw_engine
)
GameEngine
(in
pystroke.game_engine
)
GL_ACCUM_RED_SIZE
(in
pystroke.vex
)
GL_MULTISAMPLEBUFFERS
(in
pystroke.event_engine
)
get()
(in
HUD
)
GL_ALPHA_SIZE
(in
pystroke.draw_engine
)
GL_MULTISAMPLEBUFFERS
(in
pystroke.game_engine
)
get_absolute_points_tuple()
(in
Vex
)
GL_ALPHA_SIZE
(in
pystroke.event_engine
)
GL_MULTISAMPLEBUFFERS
(in
pystroke.hud
)
get_absolute_points_vector2()
(in
Vex
)
GL_ALPHA_SIZE
(in
pystroke.game_engine
)
GL_MULTISAMPLEBUFFERS
(in
pystroke.input_engine
)
get_angle()
(in
Vector2
)
GL_ALPHA_SIZE
(in
pystroke.hud
)
GL_MULTISAMPLEBUFFERS
(in
pystroke.vex
)
get_key()
(in
GameEngine
)
GL_ALPHA_SIZE
(in
pystroke.input_engine
)
GL_MULTISAMPLESAMPLES
(in
pystroke.draw_engine
)
get_magnitude()
(in
Vector2
)
GL_ALPHA_SIZE
(in
pystroke.vex
)
GL_MULTISAMPLESAMPLES
(in
pystroke.event_engine
)
get_relative_points_tuple()
(in
Vex
)
GL_BLUE_SIZE
(in
pystroke.draw_engine
)
GL_MULTISAMPLESAMPLES
(in
pystroke.game_engine
)
get_relative_points_vector2()
(in
Vex
)
GL_BLUE_SIZE
(in
pystroke.event_engine
)
GL_MULTISAMPLESAMPLES
(in
pystroke.hud
)
GL_ACCELERATED_VISUAL
(in
pystroke.draw_engine
)
GL_BLUE_SIZE
(in
pystroke.game_engine
)
GL_MULTISAMPLESAMPLES
(in
pystroke.input_engine
)
GL_ACCELERATED_VISUAL
(in
pystroke.event_engine
)
GL_BLUE_SIZE
(in
pystroke.hud
)
GL_MULTISAMPLESAMPLES
(in
pystroke.vex
)
GL_ACCELERATED_VISUAL
(in
pystroke.game_engine
)
GL_BLUE_SIZE
(in
pystroke.input_engine
)
GL_RED_SIZE
(in
pystroke.draw_engine
)
GL_ACCELERATED_VISUAL
(in
pystroke.hud
)
GL_BLUE_SIZE
(in
pystroke.vex
)
GL_RED_SIZE
(in
pystroke.event_engine
)
GL_ACCELERATED_VISUAL
(in
pystroke.input_engine
)
GL_BUFFER_SIZE
(in
pystroke.draw_engine
)
GL_RED_SIZE
(in
pystroke.game_engine
)
GL_ACCELERATED_VISUAL
(in
pystroke.vex
)
GL_BUFFER_SIZE
(in
pystroke.event_engine
)
GL_RED_SIZE
(in
pystroke.hud
)
GL_ACCUM_ALPHA_SIZE
(in
pystroke.draw_engine
)
GL_BUFFER_SIZE
(in
pystroke.game_engine
)
GL_RED_SIZE
(in
pystroke.input_engine
)
GL_ACCUM_ALPHA_SIZE
(in
pystroke.event_engine
)
GL_BUFFER_SIZE
(in
pystroke.hud
)
GL_RED_SIZE
(in
pystroke.vex
)
GL_ACCUM_ALPHA_SIZE
(in
pystroke.game_engine
)
GL_BUFFER_SIZE
(in
pystroke.input_engine
)
GL_STENCIL_SIZE
(in
pystroke.draw_engine
)
GL_ACCUM_ALPHA_SIZE
(in
pystroke.hud
)
GL_BUFFER_SIZE
(in
pystroke.vex
)
GL_STENCIL_SIZE
(in
pystroke.event_engine
)
GL_ACCUM_ALPHA_SIZE
(in
pystroke.input_engine
)
GL_DEPTH_SIZE
(in
pystroke.draw_engine
)
GL_STENCIL_SIZE
(in
pystroke.game_engine
)
GL_ACCUM_ALPHA_SIZE
(in
pystroke.vex
)
GL_DEPTH_SIZE
(in
pystroke.event_engine
)
GL_STENCIL_SIZE
(in
pystroke.hud
)
GL_ACCUM_BLUE_SIZE
(in
pystroke.draw_engine
)
GL_DEPTH_SIZE
(in
pystroke.game_engine
)
GL_STENCIL_SIZE
(in
pystroke.input_engine
)
GL_ACCUM_BLUE_SIZE
(in
pystroke.event_engine
)
GL_DEPTH_SIZE
(in
pystroke.hud
)
GL_STENCIL_SIZE
(in
pystroke.vex
)
GL_ACCUM_BLUE_SIZE
(in
pystroke.game_engine
)
GL_DEPTH_SIZE
(in
pystroke.input_engine
)
GL_STEREO
(in
pystroke.draw_engine
)
GL_ACCUM_BLUE_SIZE
(in
pystroke.hud
)
GL_DEPTH_SIZE
(in
pystroke.vex
)
GL_STEREO
(in
pystroke.event_engine
)
GL_ACCUM_BLUE_SIZE
(in
pystroke.input_engine
)
GL_DOUBLEBUFFER
(in
pystroke.draw_engine
)
GL_STEREO
(in
pystroke.game_engine
)
GL_ACCUM_BLUE_SIZE
(in
pystroke.vex
)
GL_DOUBLEBUFFER
(in
pystroke.event_engine
)
GL_STEREO
(in
pystroke.hud
)
GL_ACCUM_GREEN_SIZE
(in
pystroke.draw_engine
)
GL_DOUBLEBUFFER
(in
pystroke.game_engine
)
GL_STEREO
(in
pystroke.input_engine
)
GL_ACCUM_GREEN_SIZE
(in
pystroke.event_engine
)
GL_DOUBLEBUFFER
(in
pystroke.hud
)
GL_STEREO
(in
pystroke.vex
)
GL_ACCUM_GREEN_SIZE
(in
pystroke.game_engine
)
GL_DOUBLEBUFFER
(in
pystroke.input_engine
)
GL_SWAP_CONTROL
(in
pystroke.draw_engine
)
GL_ACCUM_GREEN_SIZE
(in
pystroke.hud
)
GL_DOUBLEBUFFER
(in
pystroke.vex
)
GL_SWAP_CONTROL
(in
pystroke.event_engine
)
GL_ACCUM_GREEN_SIZE
(in
pystroke.input_engine
)
GL_GREEN_SIZE
(in
pystroke.draw_engine
)
GL_SWAP_CONTROL
(in
pystroke.game_engine
)
GL_ACCUM_GREEN_SIZE
(in
pystroke.vex
)
GL_GREEN_SIZE
(in
pystroke.event_engine
)
GL_SWAP_CONTROL
(in
pystroke.hud
)
GL_ACCUM_RED_SIZE
(in
pystroke.draw_engine
)
GL_GREEN_SIZE
(in
pystroke.game_engine
)
GL_SWAP_CONTROL
(in
pystroke.input_engine
)
GL_ACCUM_RED_SIZE
(in
pystroke.event_engine
)
GL_GREEN_SIZE
(in
pystroke.hud
)
GL_SWAP_CONTROL
(in
pystroke.vex
)
H
HAT_CENTERED
(in
pystroke.draw_engine
)
HAT_LEFTUP
(in
pystroke.game_engine
)
HAT_UP
(in
pystroke.input_engine
)
HAT_CENTERED
(in
pystroke.event_engine
)
HAT_LEFTUP
(in
pystroke.hud
)
HAT_UP
(in
pystroke.vex
)
HAT_CENTERED
(in
pystroke.game_engine
)
HAT_LEFTUP
(in
pystroke.input_engine
)
hud
(in
pystroke
)
HAT_CENTERED
(in
pystroke.hud
)
HAT_LEFTUP
(in
pystroke.vex
)
HUD
(in
pystroke.hud
)
HAT_CENTERED
(in
pystroke.input_engine
)
HAT_RIGHT
(in
pystroke.draw_engine
)
HUDElement
(in
pystroke.hud
)
HAT_CENTERED
(in
pystroke.vex
)
HAT_RIGHT
(in
pystroke.event_engine
)
HUDLine
(in
pystroke.hud
)
HAT_DOWN
(in
pystroke.draw_engine
)
HAT_RIGHT
(in
pystroke.game_engine
)
HUDPolygon
(in
pystroke.hud
)
HAT_DOWN
(in
pystroke.event_engine
)
HAT_RIGHT
(in
pystroke.hud
)
HUDText
(in
pystroke.hud
)
HAT_DOWN
(in
pystroke.game_engine
)
HAT_RIGHT
(in
pystroke.input_engine
)
HWACCEL
(in
pystroke.draw_engine
)
HAT_DOWN
(in
pystroke.hud
)
HAT_RIGHT
(in
pystroke.vex
)
HWACCEL
(in
pystroke.event_engine
)
HAT_DOWN
(in
pystroke.input_engine
)
HAT_RIGHTDOWN
(in
pystroke.draw_engine
)
HWACCEL
(in
pystroke.game_engine
)
HAT_DOWN
(in
pystroke.vex
)
HAT_RIGHTDOWN
(in
pystroke.event_engine
)
HWACCEL
(in
pystroke.hud
)
HAT_LEFT
(in
pystroke.draw_engine
)
HAT_RIGHTDOWN
(in
pystroke.game_engine
)
HWACCEL
(in
pystroke.input_engine
)
HAT_LEFT
(in
pystroke.event_engine
)
HAT_RIGHTDOWN
(in
pystroke.hud
)
HWACCEL
(in
pystroke.vex
)
HAT_LEFT
(in
pystroke.game_engine
)
HAT_RIGHTDOWN
(in
pystroke.input_engine
)
HWPALETTE
(in
pystroke.draw_engine
)
HAT_LEFT
(in
pystroke.hud
)
HAT_RIGHTDOWN
(in
pystroke.vex
)
HWPALETTE
(in
pystroke.event_engine
)
HAT_LEFT
(in
pystroke.input_engine
)
HAT_RIGHTUP
(in
pystroke.draw_engine
)
HWPALETTE
(in
pystroke.game_engine
)
HAT_LEFT
(in
pystroke.vex
)
HAT_RIGHTUP
(in
pystroke.event_engine
)
HWPALETTE
(in
pystroke.hud
)
HAT_LEFTDOWN
(in
pystroke.draw_engine
)
HAT_RIGHTUP
(in
pystroke.game_engine
)
HWPALETTE
(in
pystroke.input_engine
)
HAT_LEFTDOWN
(in
pystroke.event_engine
)
HAT_RIGHTUP
(in
pystroke.hud
)
HWPALETTE
(in
pystroke.vex
)
HAT_LEFTDOWN
(in
pystroke.game_engine
)
HAT_RIGHTUP
(in
pystroke.input_engine
)
HWSURFACE
(in
pystroke.draw_engine
)
HAT_LEFTDOWN
(in
pystroke.hud
)
HAT_RIGHTUP
(in
pystroke.vex
)
HWSURFACE
(in
pystroke.event_engine
)
HAT_LEFTDOWN
(in
pystroke.input_engine
)
HAT_UP
(in
pystroke.draw_engine
)
HWSURFACE
(in
pystroke.game_engine
)
HAT_LEFTDOWN
(in
pystroke.vex
)
HAT_UP
(in
pystroke.event_engine
)
HWSURFACE
(in
pystroke.hud
)
HAT_LEFTUP
(in
pystroke.draw_engine
)
HAT_UP
(in
pystroke.game_engine
)
HWSURFACE
(in
pystroke.input_engine
)
HAT_LEFTUP
(in
pystroke.event_engine
)
HAT_UP
(in
pystroke.hud
)
HWSURFACE
(in
pystroke.vex
)
I
input_engine
(in
pystroke
)
IYUV_OVERLAY
(in
pystroke.event_engine
)
IYUV_OVERLAY
(in
pystroke.input_engine
)
InputEngine
(in
pystroke.input_engine
)
IYUV_OVERLAY
(in
pystroke.game_engine
)
IYUV_OVERLAY
(in
pystroke.vex
)
IYUV_OVERLAY
(in
pystroke.draw_engine
)
IYUV_OVERLAY
(in
pystroke.hud
)
J
JOYAXISMOTION
(in
pystroke.draw_engine
)
JOYBALLMOTION
(in
pystroke.input_engine
)
JOYBUTTONUP
(in
pystroke.game_engine
)
JOYAXISMOTION
(in
pystroke.event_engine
)
JOYBALLMOTION
(in
pystroke.vex
)
JOYBUTTONUP
(in
pystroke.hud
)
JOYAXISMOTION
(in
pystroke.game_engine
)
JOYBUTTONDOWN
(in
pystroke.draw_engine
)
JOYBUTTONUP
(in
pystroke.input_engine
)
JOYAXISMOTION
(in
pystroke.hud
)
JOYBUTTONDOWN
(in
pystroke.event_engine
)
JOYBUTTONUP
(in
pystroke.vex
)
JOYAXISMOTION
(in
pystroke.input_engine
)
JOYBUTTONDOWN
(in
pystroke.game_engine
)
JOYHATMOTION
(in
pystroke.draw_engine
)
JOYAXISMOTION
(in
pystroke.vex
)
JOYBUTTONDOWN
(in
pystroke.hud
)
JOYHATMOTION
(in
pystroke.event_engine
)
JOYBALLMOTION
(in
pystroke.draw_engine
)
JOYBUTTONDOWN
(in
pystroke.input_engine
)
JOYHATMOTION
(in
pystroke.game_engine
)
JOYBALLMOTION
(in
pystroke.event_engine
)
JOYBUTTONDOWN
(in
pystroke.vex
)
JOYHATMOTION
(in
pystroke.hud
)
JOYBALLMOTION
(in
pystroke.game_engine
)
JOYBUTTONUP
(in
pystroke.draw_engine
)
JOYHATMOTION
(in
pystroke.input_engine
)
JOYBALLMOTION
(in
pystroke.hud
)
JOYBUTTONUP
(in
pystroke.event_engine
)
JOYHATMOTION
(in
pystroke.vex
)
K
K_0
(in
pystroke.draw_engine
)
K_FIRST
(in
pystroke.hud
)
K_POWER
(in
pystroke.draw_engine
)
K_0
(in
pystroke.event_engine
)
K_FIRST
(in
pystroke.input_engine
)
K_POWER
(in
pystroke.event_engine
)
K_0
(in
pystroke.game_engine
)
K_FIRST
(in
pystroke.vex
)
K_POWER
(in
pystroke.game_engine
)
K_0
(in
pystroke.hud
)
K_g
(in
pystroke.draw_engine
)
K_POWER
(in
pystroke.hud
)
K_0
(in
pystroke.input_engine
)
K_g
(in
pystroke.event_engine
)
K_POWER
(in
pystroke.input_engine
)
K_0
(in
pystroke.vex
)
K_g
(in
pystroke.game_engine
)
K_POWER
(in
pystroke.vex
)
K_1
(in
pystroke.draw_engine
)
K_g
(in
pystroke.hud
)
K_PRINT
(in
pystroke.draw_engine
)
K_1
(in
pystroke.event_engine
)
K_g
(in
pystroke.input_engine
)
K_PRINT
(in
pystroke.event_engine
)
K_1
(in
pystroke.game_engine
)
K_g
(in
pystroke.vex
)
K_PRINT
(in
pystroke.game_engine
)
K_1
(in
pystroke.hud
)
K_GREATER
(in
pystroke.draw_engine
)
K_PRINT
(in
pystroke.hud
)
K_1
(in
pystroke.input_engine
)
K_GREATER
(in
pystroke.event_engine
)
K_PRINT
(in
pystroke.input_engine
)
K_1
(in
pystroke.vex
)
K_GREATER
(in
pystroke.game_engine
)
K_PRINT
(in
pystroke.vex
)
K_2
(in
pystroke.draw_engine
)
K_GREATER
(in
pystroke.hud
)
K_q
(in
pystroke.draw_engine
)
K_2
(in
pystroke.event_engine
)
K_GREATER
(in
pystroke.input_engine
)
K_q
(in
pystroke.event_engine
)
K_2
(in
pystroke.game_engine
)
K_GREATER
(in
pystroke.vex
)
K_q
(in
pystroke.game_engine
)
K_2
(in
pystroke.hud
)
K_h
(in
pystroke.draw_engine
)
K_q
(in
pystroke.hud
)
K_2
(in
pystroke.input_engine
)
K_h
(in
pystroke.event_engine
)
K_q
(in
pystroke.input_engine
)
K_2
(in
pystroke.vex
)
K_h
(in
pystroke.game_engine
)
K_q
(in
pystroke.vex
)
K_3
(in
pystroke.draw_engine
)
K_h
(in
pystroke.hud
)
K_QUESTION
(in
pystroke.draw_engine
)
K_3
(in
pystroke.event_engine
)
K_h
(in
pystroke.input_engine
)
K_QUESTION
(in
pystroke.event_engine
)
K_3
(in
pystroke.game_engine
)
K_h
(in
pystroke.vex
)
K_QUESTION
(in
pystroke.game_engine
)
K_3
(in
pystroke.hud
)
K_HASH
(in
pystroke.draw_engine
)
K_QUESTION
(in
pystroke.hud
)
K_3
(in
pystroke.input_engine
)
K_HASH
(in
pystroke.event_engine
)
K_QUESTION
(in
pystroke.input_engine
)
K_3
(in
pystroke.vex
)
K_HASH
(in
pystroke.game_engine
)
K_QUESTION
(in
pystroke.vex
)
K_4
(in
pystroke.draw_engine
)
K_HASH
(in
pystroke.hud
)
K_QUOTE
(in
pystroke.draw_engine
)
K_4
(in
pystroke.event_engine
)
K_HASH
(in
pystroke.input_engine
)
K_QUOTE
(in
pystroke.event_engine
)
K_4
(in
pystroke.game_engine
)
K_HASH
(in
pystroke.vex
)
K_QUOTE
(in
pystroke.game_engine
)
K_4
(in
pystroke.hud
)
K_HELP
(in
pystroke.draw_engine
)
K_QUOTE
(in
pystroke.hud
)
K_4
(in
pystroke.input_engine
)
K_HELP
(in
pystroke.event_engine
)
K_QUOTE
(in
pystroke.input_engine
)
K_4
(in
pystroke.vex
)
K_HELP
(in
pystroke.game_engine
)
K_QUOTE
(in
pystroke.vex
)
K_5
(in
pystroke.draw_engine
)
K_HELP
(in
pystroke.hud
)
K_QUOTEDBL
(in
pystroke.draw_engine
)
K_5
(in
pystroke.event_engine
)
K_HELP
(in
pystroke.input_engine
)
K_QUOTEDBL
(in
pystroke.event_engine
)
K_5
(in
pystroke.game_engine
)
K_HELP
(in
pystroke.vex
)
K_QUOTEDBL
(in
pystroke.game_engine
)
K_5
(in
pystroke.hud
)
K_HOME
(in
pystroke.draw_engine
)
K_QUOTEDBL
(in
pystroke.hud
)
K_5
(in
pystroke.input_engine
)
K_HOME
(in
pystroke.event_engine
)
K_QUOTEDBL
(in
pystroke.input_engine
)
K_5
(in
pystroke.vex
)
K_HOME
(in
pystroke.game_engine
)
K_QUOTEDBL
(in
pystroke.vex
)
K_6
(in
pystroke.draw_engine
)
K_HOME
(in
pystroke.hud
)
K_r
(in
pystroke.draw_engine
)
K_6
(in
pystroke.event_engine
)
K_HOME
(in
pystroke.input_engine
)
K_r
(in
pystroke.event_engine
)
K_6
(in
pystroke.game_engine
)
K_HOME
(in
pystroke.vex
)
K_r
(in
pystroke.game_engine
)
K_6
(in
pystroke.hud
)
K_i
(in
pystroke.draw_engine
)
K_r
(in
pystroke.hud
)
K_6
(in
pystroke.input_engine
)
K_i
(in
pystroke.event_engine
)
K_r
(in
pystroke.input_engine
)
K_6
(in
pystroke.vex
)
K_i
(in
pystroke.game_engine
)
K_r
(in
pystroke.vex
)
K_7
(in
pystroke.draw_engine
)
K_i
(in
pystroke.hud
)
K_RALT
(in
pystroke.draw_engine
)
K_7
(in
pystroke.event_engine
)
K_i
(in
pystroke.input_engine
)
K_RALT
(in
pystroke.event_engine
)
K_7
(in
pystroke.game_engine
)
K_i
(in
pystroke.vex
)
K_RALT
(in
pystroke.game_engine
)
K_7
(in
pystroke.hud
)
K_INSERT
(in
pystroke.draw_engine
)
K_RALT
(in
pystroke.hud
)
K_7
(in
pystroke.input_engine
)
K_INSERT
(in
pystroke.event_engine
)
K_RALT
(in
pystroke.input_engine
)
K_7
(in
pystroke.vex
)
K_INSERT
(in
pystroke.game_engine
)
K_RALT
(in
pystroke.vex
)
K_8
(in
pystroke.draw_engine
)
K_INSERT
(in
pystroke.hud
)
K_RCTRL
(in
pystroke.draw_engine
)
K_8
(in
pystroke.event_engine
)
K_INSERT
(in
pystroke.input_engine
)
K_RCTRL
(in
pystroke.event_engine
)
K_8
(in
pystroke.game_engine
)
K_INSERT
(in
pystroke.vex
)
K_RCTRL
(in
pystroke.game_engine
)
K_8
(in
pystroke.hud
)
K_j
(in
pystroke.draw_engine
)
K_RCTRL
(in
pystroke.hud
)
K_8
(in
pystroke.input_engine
)
K_j
(in
pystroke.event_engine
)
K_RCTRL
(in
pystroke.input_engine
)
K_8
(in
pystroke.vex
)
K_j
(in
pystroke.game_engine
)
K_RCTRL
(in
pystroke.vex
)
K_9
(in
pystroke.draw_engine
)
K_j
(in
pystroke.hud
)
K_RETURN
(in
pystroke.draw_engine
)
K_9
(in
pystroke.event_engine
)
K_j
(in
pystroke.input_engine
)
K_RETURN
(in
pystroke.event_engine
)
K_9
(in
pystroke.game_engine
)
K_j
(in
pystroke.vex
)
K_RETURN
(in
pystroke.game_engine
)
K_9
(in
pystroke.hud
)
K_k
(in
pystroke.draw_engine
)
K_RETURN
(in
pystroke.hud
)
K_9
(in
pystroke.input_engine
)
K_k
(in
pystroke.event_engine
)
K_RETURN
(in
pystroke.input_engine
)
K_9
(in
pystroke.vex
)
K_k
(in
pystroke.game_engine
)
K_RETURN
(in
pystroke.vex
)
K_a
(in
pystroke.draw_engine
)
K_k
(in
pystroke.hud
)
K_RIGHT
(in
pystroke.draw_engine
)
K_a
(in
pystroke.event_engine
)
K_k
(in
pystroke.input_engine
)
K_RIGHT
(in
pystroke.event_engine
)
K_a
(in
pystroke.game_engine
)
K_k
(in
pystroke.vex
)
K_RIGHT
(in
pystroke.game_engine
)
K_a
(in
pystroke.hud
)
K_KP0
(in
pystroke.draw_engine
)
K_RIGHT
(in
pystroke.hud
)
K_a
(in
pystroke.input_engine
)
K_KP0
(in
pystroke.event_engine
)
K_RIGHT
(in
pystroke.input_engine
)
K_a
(in
pystroke.vex
)
K_KP0
(in
pystroke.game_engine
)
K_RIGHT
(in
pystroke.vex
)
K_AMPERSAND
(in
pystroke.draw_engine
)
K_KP0
(in
pystroke.hud
)
K_RIGHTBRACKET
(in
pystroke.draw_engine
)
K_AMPERSAND
(in
pystroke.event_engine
)
K_KP0
(in
pystroke.input_engine
)
K_RIGHTBRACKET
(in
pystroke.event_engine
)
K_AMPERSAND
(in
pystroke.game_engine
)
K_KP0
(in
pystroke.vex
)
K_RIGHTBRACKET
(in
pystroke.game_engine
)
K_AMPERSAND
(in
pystroke.hud
)
K_KP1
(in
pystroke.draw_engine
)
K_RIGHTBRACKET
(in
pystroke.hud
)
K_AMPERSAND
(in
pystroke.input_engine
)
K_KP1
(in
pystroke.event_engine
)
K_RIGHTBRACKET
(in
pystroke.input_engine
)
K_AMPERSAND
(in
pystroke.vex
)
K_KP1
(in
pystroke.game_engine
)
K_RIGHTBRACKET
(in
pystroke.vex
)
K_ASTERISK
(in
pystroke.draw_engine
)
K_KP1
(in
pystroke.hud
)
K_RIGHTPAREN
(in
pystroke.draw_engine
)
K_ASTERISK
(in
pystroke.event_engine
)
K_KP1
(in
pystroke.input_engine
)
K_RIGHTPAREN
(in
pystroke.event_engine
)
K_ASTERISK
(in
pystroke.game_engine
)
K_KP1
(in
pystroke.vex
)
K_RIGHTPAREN
(in
pystroke.game_engine
)
K_ASTERISK
(in
pystroke.hud
)
K_KP2
(in
pystroke.draw_engine
)
K_RIGHTPAREN
(in
pystroke.hud
)
K_ASTERISK
(in
pystroke.input_engine
)
K_KP2
(in
pystroke.event_engine
)
K_RIGHTPAREN
(in
pystroke.input_engine
)
K_ASTERISK
(in
pystroke.vex
)
K_KP2
(in
pystroke.game_engine
)
K_RIGHTPAREN
(in
pystroke.vex
)
K_AT
(in
pystroke.draw_engine
)
K_KP2
(in
pystroke.hud
)
K_RMETA
(in
pystroke.draw_engine
)
K_AT
(in
pystroke.event_engine
)
K_KP2
(in
pystroke.input_engine
)
K_RMETA
(in
pystroke.event_engine
)
K_AT
(in
pystroke.game_engine
)
K_KP2
(in
pystroke.vex
)
K_RMETA
(in
pystroke.game_engine
)
K_AT
(in
pystroke.hud
)
K_KP3
(in
pystroke.draw_engine
)
K_RMETA
(in
pystroke.hud
)
K_AT
(in
pystroke.input_engine
)
K_KP3
(in
pystroke.event_engine
)
K_RMETA
(in
pystroke.input_engine
)
K_AT
(in
pystroke.vex
)
K_KP3
(in
pystroke.game_engine
)
K_RMETA
(in
pystroke.vex
)
K_b
(in
pystroke.draw_engine
)
K_KP3
(in
pystroke.hud
)
K_RSHIFT
(in
pystroke.draw_engine
)
K_b
(in
pystroke.event_engine
)
K_KP3
(in
pystroke.input_engine
)
K_RSHIFT
(in
pystroke.event_engine
)
K_b
(in
pystroke.game_engine
)
K_KP3
(in
pystroke.vex
)
K_RSHIFT
(in
pystroke.game_engine
)
K_b
(in
pystroke.hud
)
K_KP4
(in
pystroke.draw_engine
)
K_RSHIFT
(in
pystroke.hud
)
K_b
(in
pystroke.input_engine
)
K_KP4
(in
pystroke.event_engine
)
K_RSHIFT
(in
pystroke.input_engine
)
K_b
(in
pystroke.vex
)
K_KP4
(in
pystroke.game_engine
)
K_RSHIFT
(in
pystroke.vex
)
K_BACKQUOTE
(in
pystroke.draw_engine
)
K_KP4
(in
pystroke.hud
)
K_RSUPER
(in
pystroke.draw_engine
)
K_BACKQUOTE
(in
pystroke.event_engine
)
K_KP4
(in
pystroke.input_engine
)
K_RSUPER
(in
pystroke.event_engine
)
K_BACKQUOTE
(in
pystroke.game_engine
)
K_KP4
(in
pystroke.vex
)
K_RSUPER
(in
pystroke.game_engine
)
K_BACKQUOTE
(in
pystroke.hud
)
K_KP5
(in
pystroke.draw_engine
)
K_RSUPER
(in
pystroke.hud
)
K_BACKQUOTE
(in
pystroke.input_engine
)
K_KP5
(in
pystroke.event_engine
)
K_RSUPER
(in
pystroke.input_engine
)
K_BACKQUOTE
(in
pystroke.vex
)
K_KP5
(in
pystroke.game_engine
)
K_RSUPER
(in
pystroke.vex
)
K_BACKSLASH
(in
pystroke.draw_engine
)
K_KP5
(in
pystroke.hud
)
K_s
(in
pystroke.draw_engine
)
K_BACKSLASH
(in
pystroke.event_engine
)
K_KP5
(in
pystroke.input_engine
)
K_s
(in
pystroke.event_engine
)
K_BACKSLASH
(in
pystroke.game_engine
)
K_KP5
(in
pystroke.vex
)
K_s
(in
pystroke.game_engine
)
K_BACKSLASH
(in
pystroke.hud
)
K_KP6
(in
pystroke.draw_engine
)
K_s
(in
pystroke.hud
)
K_BACKSLASH
(in
pystroke.input_engine
)
K_KP6
(in
pystroke.event_engine
)
K_s
(in
pystroke.input_engine
)
K_BACKSLASH
(in
pystroke.vex
)
K_KP6
(in
pystroke.game_engine
)
K_s
(in
pystroke.vex
)
K_BACKSPACE
(in
pystroke.draw_engine
)
K_KP6
(in
pystroke.hud
)
K_SCROLLOCK
(in
pystroke.draw_engine
)
K_BACKSPACE
(in
pystroke.event_engine
)
K_KP6
(in
pystroke.input_engine
)
K_SCROLLOCK
(in
pystroke.event_engine
)
K_BACKSPACE
(in
pystroke.game_engine
)
K_KP6
(in
pystroke.vex
)
K_SCROLLOCK
(in
pystroke.game_engine
)
K_BACKSPACE
(in
pystroke.hud
)
K_KP7
(in
pystroke.draw_engine
)
K_SCROLLOCK
(in
pystroke.hud
)
K_BACKSPACE
(in
pystroke.input_engine
)
K_KP7
(in
pystroke.event_engine
)
K_SCROLLOCK
(in
pystroke.input_engine
)
K_BACKSPACE
(in
pystroke.vex
)
K_KP7
(in
pystroke.game_engine
)
K_SCROLLOCK
(in
pystroke.vex
)
K_BREAK
(in
pystroke.draw_engine
)
K_KP7
(in
pystroke.hud
)
K_SEMICOLON
(in
pystroke.draw_engine
)
K_BREAK
(in
pystroke.event_engine
)
K_KP7
(in
pystroke.input_engine
)
K_SEMICOLON
(in
pystroke.event_engine
)
K_BREAK
(in
pystroke.game_engine
)
K_KP7
(in
pystroke.vex
)
K_SEMICOLON
(in
pystroke.game_engine
)
K_BREAK
(in
pystroke.hud
)
K_KP8
(in
pystroke.draw_engine
)
K_SEMICOLON
(in
pystroke.hud
)
K_BREAK
(in
pystroke.input_engine
)
K_KP8
(in
pystroke.event_engine
)
K_SEMICOLON
(in
pystroke.input_engine
)
K_BREAK
(in
pystroke.vex
)
K_KP8
(in
pystroke.game_engine
)
K_SEMICOLON
(in
pystroke.vex
)
K_c
(in
pystroke.draw_engine
)
K_KP8
(in
pystroke.hud
)
K_SLASH
(in
pystroke.draw_engine
)
K_c
(in
pystroke.event_engine
)
K_KP8
(in
pystroke.input_engine
)
K_SLASH
(in
pystroke.event_engine
)
K_c
(in
pystroke.game_engine
)
K_KP8
(in
pystroke.vex
)
K_SLASH
(in
pystroke.game_engine
)
K_c
(in
pystroke.hud
)
K_KP9
(in
pystroke.draw_engine
)
K_SLASH
(in
pystroke.hud
)
K_c
(in
pystroke.input_engine
)
K_KP9
(in
pystroke.event_engine
)
K_SLASH
(in
pystroke.input_engine
)
K_c
(in
pystroke.vex
)
K_KP9
(in
pystroke.game_engine
)
K_SLASH
(in
pystroke.vex
)
K_CAPSLOCK
(in
pystroke.draw_engine
)
K_KP9
(in
pystroke.hud
)
K_SPACE
(in
pystroke.draw_engine
)
K_CAPSLOCK
(in
pystroke.event_engine
)
K_KP9
(in
pystroke.input_engine
)
K_SPACE
(in
pystroke.event_engine
)
K_CAPSLOCK
(in
pystroke.game_engine
)
K_KP9
(in
pystroke.vex
)
K_SPACE
(in
pystroke.game_engine
)
K_CAPSLOCK
(in
pystroke.hud
)
K_KP_DIVIDE
(in
pystroke.draw_engine
)
K_SPACE
(in
pystroke.hud
)
K_CAPSLOCK
(in
pystroke.input_engine
)
K_KP_DIVIDE
(in
pystroke.event_engine
)
K_SPACE
(in
pystroke.input_engine
)
K_CAPSLOCK
(in
pystroke.vex
)
K_KP_DIVIDE
(in
pystroke.game_engine
)
K_SPACE
(in
pystroke.vex
)
K_CARET
(in
pystroke.draw_engine
)
K_KP_DIVIDE
(in
pystroke.hud
)
K_SYSREQ
(in
pystroke.draw_engine
)
K_CARET
(in
pystroke.event_engine
)
K_KP_DIVIDE
(in
pystroke.input_engine
)
K_SYSREQ
(in
pystroke.event_engine
)
K_CARET
(in
pystroke.game_engine
)
K_KP_DIVIDE
(in
pystroke.vex
)
K_SYSREQ
(in
pystroke.game_engine
)
K_CARET
(in
pystroke.hud
)
K_KP_ENTER
(in
pystroke.draw_engine
)
K_SYSREQ
(in
pystroke.hud
)
K_CARET
(in
pystroke.input_engine
)
K_KP_ENTER
(in
pystroke.event_engine
)
K_SYSREQ
(in
pystroke.input_engine
)
K_CARET
(in
pystroke.vex
)
K_KP_ENTER
(in
pystroke.game_engine
)
K_SYSREQ
(in
pystroke.vex
)
K_CLEAR
(in
pystroke.draw_engine
)
K_KP_ENTER
(in
pystroke.hud
)
K_t
(in
pystroke.draw_engine
)
K_CLEAR
(in
pystroke.event_engine
)
K_KP_ENTER
(in
pystroke.input_engine
)
K_t
(in
pystroke.event_engine
)
K_CLEAR
(in
pystroke.game_engine
)
K_KP_ENTER
(in
pystroke.vex
)
K_t
(in
pystroke.game_engine
)
K_CLEAR
(in
pystroke.hud
)
K_KP_EQUALS
(in
pystroke.draw_engine
)
K_t
(in
pystroke.hud
)
K_CLEAR
(in
pystroke.input_engine
)
K_KP_EQUALS
(in
pystroke.event_engine
)
K_t
(in
pystroke.input_engine
)
K_CLEAR
(in
pystroke.vex
)
K_KP_EQUALS
(in
pystroke.game_engine
)
K_t
(in
pystroke.vex
)
K_COLON
(in
pystroke.draw_engine
)
K_KP_EQUALS
(in
pystroke.hud
)
K_TAB
(in
pystroke.draw_engine
)
K_COLON
(in
pystroke.event_engine
)
K_KP_EQUALS
(in
pystroke.input_engine
)
K_TAB
(in
pystroke.event_engine
)
K_COLON
(in
pystroke.game_engine
)
K_KP_EQUALS
(in
pystroke.vex
)
K_TAB
(in
pystroke.game_engine
)
K_COLON
(in
pystroke.hud
)
K_KP_MINUS
(in
pystroke.draw_engine
)
K_TAB
(in
pystroke.hud
)
K_COLON
(in
pystroke.input_engine
)
K_KP_MINUS
(in
pystroke.event_engine
)
K_TAB
(in
pystroke.input_engine
)
K_COLON
(in
pystroke.vex
)
K_KP_MINUS
(in
pystroke.game_engine
)
K_TAB
(in
pystroke.vex
)
K_COMMA
(in
pystroke.draw_engine
)
K_KP_MINUS
(in
pystroke.hud
)
K_u
(in
pystroke.draw_engine
)
K_COMMA
(in
pystroke.event_engine
)
K_KP_MINUS
(in
pystroke.input_engine
)
K_u
(in
pystroke.event_engine
)
K_COMMA
(in
pystroke.game_engine
)
K_KP_MINUS
(in
pystroke.vex
)
K_u
(in
pystroke.game_engine
)
K_COMMA
(in
pystroke.hud
)
K_KP_MULTIPLY
(in
pystroke.draw_engine
)
K_u
(in
pystroke.hud
)
K_COMMA
(in
pystroke.input_engine
)
K_KP_MULTIPLY
(in
pystroke.event_engine
)
K_u
(in
pystroke.input_engine
)
K_COMMA
(in
pystroke.vex
)
K_KP_MULTIPLY
(in
pystroke.game_engine
)
K_u
(in
pystroke.vex
)
K_d
(in
pystroke.draw_engine
)
K_KP_MULTIPLY
(in
pystroke.hud
)
K_UNDERSCORE
(in
pystroke.draw_engine
)
K_d
(in
pystroke.event_engine
)
K_KP_MULTIPLY
(in
pystroke.input_engine
)
K_UNDERSCORE
(in
pystroke.event_engine
)
K_d
(in
pystroke.game_engine
)
K_KP_MULTIPLY
(in
pystroke.vex
)
K_UNDERSCORE
(in
pystroke.game_engine
)
K_d
(in
pystroke.hud
)
K_KP_PERIOD
(in
pystroke.draw_engine
)
K_UNDERSCORE
(in
pystroke.hud
)
K_d
(in
pystroke.input_engine
)
K_KP_PERIOD
(in
pystroke.event_engine
)
K_UNDERSCORE
(in
pystroke.input_engine
)
K_d
(in
pystroke.vex
)
K_KP_PERIOD
(in
pystroke.game_engine
)
K_UNDERSCORE
(in
pystroke.vex
)
K_DELETE
(in
pystroke.draw_engine
)
K_KP_PERIOD
(in
pystroke.hud
)
K_UNKNOWN
(in
pystroke.draw_engine
)
K_DELETE
(in
pystroke.event_engine
)
K_KP_PERIOD
(in
pystroke.input_engine
)
K_UNKNOWN
(in
pystroke.event_engine
)
K_DELETE
(in
pystroke.game_engine
)
K_KP_PERIOD
(in
pystroke.vex
)
K_UNKNOWN
(in
pystroke.game_engine
)
K_DELETE
(in
pystroke.hud
)
K_KP_PLUS
(in
pystroke.draw_engine
)
K_UNKNOWN
(in
pystroke.hud
)
K_DELETE
(in
pystroke.input_engine
)
K_KP_PLUS
(in
pystroke.event_engine
)
K_UNKNOWN
(in
pystroke.input_engine
)
K_DELETE
(in
pystroke.vex
)
K_KP_PLUS
(in
pystroke.game_engine
)
K_UNKNOWN
(in
pystroke.vex
)
K_DOLLAR
(in
pystroke.draw_engine
)
K_KP_PLUS
(in
pystroke.hud
)
K_UP
(in
pystroke.draw_engine
)
K_DOLLAR
(in
pystroke.event_engine
)
K_KP_PLUS
(in
pystroke.input_engine
)
K_UP
(in
pystroke.event_engine
)
K_DOLLAR
(in
pystroke.game_engine
)
K_KP_PLUS
(in
pystroke.vex
)
K_UP
(in
pystroke.game_engine
)
K_DOLLAR
(in
pystroke.hud
)
K_l
(in
pystroke.draw_engine
)
K_UP
(in
pystroke.hud
)
K_DOLLAR
(in
pystroke.input_engine
)
K_l
(in
pystroke.event_engine
)
K_UP
(in
pystroke.input_engine
)
K_DOLLAR
(in
pystroke.vex
)
K_l
(in
pystroke.game_engine
)
K_UP
(in
pystroke.vex
)
K_DOWN
(in
pystroke.draw_engine
)
K_l
(in
pystroke.hud
)
K_v
(in
pystroke.draw_engine
)
K_DOWN
(in
pystroke.event_engine
)
K_l
(in
pystroke.input_engine
)
K_v
(in
pystroke.event_engine
)
K_DOWN
(in
pystroke.game_engine
)
K_l
(in
pystroke.vex
)
K_v
(in
pystroke.game_engine
)
K_DOWN
(in
pystroke.hud
)
K_LALT
(in
pystroke.draw_engine
)
K_v
(in
pystroke.hud
)
K_DOWN
(in
pystroke.input_engine
)
K_LALT
(in
pystroke.event_engine
)
K_v
(in
pystroke.input_engine
)
K_DOWN
(in
pystroke.vex
)
K_LALT
(in
pystroke.game_engine
)
K_v
(in
pystroke.vex
)
K_e
(in
pystroke.draw_engine
)
K_LALT
(in
pystroke.hud
)
K_w
(in
pystroke.draw_engine
)
K_e
(in
pystroke.event_engine
)
K_LALT
(in
pystroke.input_engine
)
K_w
(in
pystroke.event_engine
)
K_e
(in
pystroke.game_engine
)
K_LALT
(in
pystroke.vex
)
K_w
(in
pystroke.game_engine
)
K_e
(in
pystroke.hud
)
K_LAST
(in
pystroke.draw_engine
)
K_w
(in
pystroke.hud
)
K_e
(in
pystroke.input_engine
)
K_LAST
(in
pystroke.event_engine
)
K_w
(in
pystroke.input_engine
)
K_e
(in
pystroke.vex
)
K_LAST
(in
pystroke.game_engine
)
K_w
(in
pystroke.vex
)
K_END
(in
pystroke.draw_engine
)
K_LAST
(in
pystroke.hud
)
K_x
(in
pystroke.draw_engine
)
K_END
(in
pystroke.event_engine
)
K_LAST
(in
pystroke.input_engine
)
K_x
(in
pystroke.event_engine
)
K_END
(in
pystroke.game_engine
)
K_LAST
(in
pystroke.vex
)
K_x
(in
pystroke.game_engine
)
K_END
(in
pystroke.hud
)
K_LCTRL
(in
pystroke.draw_engine
)
K_x
(in
pystroke.hud
)
K_END
(in
pystroke.input_engine
)
K_LCTRL
(in
pystroke.event_engine
)
K_x
(in
pystroke.input_engine
)
K_END
(in
pystroke.vex
)
K_LCTRL
(in
pystroke.game_engine
)
K_x
(in
pystroke.vex
)
K_EQUALS
(in
pystroke.draw_engine
)
K_LCTRL
(in
pystroke.hud
)
K_y
(in
pystroke.draw_engine
)
K_EQUALS
(in
pystroke.event_engine
)
K_LCTRL
(in
pystroke.input_engine
)
K_y
(in
pystroke.event_engine
)
K_EQUALS
(in
pystroke.game_engine
)
K_LCTRL
(in
pystroke.vex
)
K_y
(in
pystroke.game_engine
)
K_EQUALS
(in
pystroke.hud
)
K_LEFT
(in
pystroke.draw_engine
)
K_y
(in
pystroke.hud
)
K_EQUALS
(in
pystroke.input_engine
)
K_LEFT
(in
pystroke.event_engine
)
K_y
(in
pystroke.input_engine
)
K_EQUALS
(in
pystroke.vex
)
K_LEFT
(in
pystroke.game_engine
)
K_y
(in
pystroke.vex
)
K_ESCAPE
(in
pystroke.draw_engine
)
K_LEFT
(in
pystroke.hud
)
K_z
(in
pystroke.draw_engine
)
K_ESCAPE
(in
pystroke.event_engine
)
K_LEFT
(in
pystroke.input_engine
)
K_z
(in
pystroke.event_engine
)
K_ESCAPE
(in
pystroke.game_engine
)
K_LEFT
(in
pystroke.vex
)
K_z
(in
pystroke.game_engine
)
K_ESCAPE
(in
pystroke.hud
)
K_LEFTBRACKET
(in
pystroke.draw_engine
)
K_z
(in
pystroke.hud
)
K_ESCAPE
(in
pystroke.input_engine
)
K_LEFTBRACKET
(in
pystroke.event_engine
)
K_z
(in
pystroke.input_engine
)
K_ESCAPE
(in
pystroke.vex
)
K_LEFTBRACKET
(in
pystroke.game_engine
)
K_z
(in
pystroke.vex
)
K_EURO
(in
pystroke.draw_engine
)
K_LEFTBRACKET
(in
pystroke.hud
)
key_down()
(in
InputEngine
)
K_EURO
(in
pystroke.event_engine
)
K_LEFTBRACKET
(in
pystroke.input_engine
)
key_up()
(in
InputEngine
)
K_EURO
(in
pystroke.game_engine
)
K_LEFTBRACKET
(in
pystroke.vex
)
KEYDOWN
(in
pystroke.draw_engine
)
K_EURO
(in
pystroke.hud
)
K_LEFTPAREN
(in
pystroke.draw_engine
)
KEYDOWN
(in
pystroke.event_engine
)
K_EURO
(in
pystroke.input_engine
)
K_LEFTPAREN
(in
pystroke.event_engine
)
KEYDOWN
(in
pystroke.game_engine
)
K_EURO
(in
pystroke.vex
)
K_LEFTPAREN
(in
pystroke.game_engine
)
KEYDOWN
(in
pystroke.hud
)
K_EXCLAIM
(in
pystroke.draw_engine
)
K_LEFTPAREN
(in
pystroke.hud
)
KEYDOWN
(in
pystroke.input_engine
)
K_EXCLAIM
(in
pystroke.event_engine
)
K_LEFTPAREN
(in
pystroke.input_engine
)
KEYDOWN
(in
pystroke.vex
)
K_EXCLAIM
(in
pystroke.game_engine
)
K_LEFTPAREN
(in
pystroke.vex
)
KEYUP
(in
pystroke.draw_engine
)
K_EXCLAIM
(in
pystroke.hud
)
K_LESS
(in
pystroke.draw_engine
)
KEYUP
(in
pystroke.event_engine
)
K_EXCLAIM
(in
pystroke.input_engine
)
K_LESS
(in
pystroke.event_engine
)
KEYUP
(in
pystroke.game_engine
)
K_EXCLAIM
(in
pystroke.vex
)
K_LESS
(in
pystroke.game_engine
)
KEYUP
(in
pystroke.hud
)
K_f
(in
pystroke.draw_engine
)
K_LESS
(in
pystroke.hud
)
KEYUP
(in
pystroke.input_engine
)
K_f
(in
pystroke.event_engine
)
K_LESS
(in
pystroke.input_engine
)
KEYUP
(in
pystroke.vex
)
K_f
(in
pystroke.game_engine
)
K_LESS
(in
pystroke.vex
)
KMOD_ALT
(in
pystroke.draw_engine
)
K_f
(in
pystroke.hud
)
K_LMETA
(in
pystroke.draw_engine
)
KMOD_ALT
(in
pystroke.event_engine
)
K_f
(in
pystroke.input_engine
)
K_LMETA
(in
pystroke.event_engine
)
KMOD_ALT
(in
pystroke.game_engine
)
K_f
(in
pystroke.vex
)
K_LMETA
(in
pystroke.game_engine
)
KMOD_ALT
(in
pystroke.hud
)
K_F1
(in
pystroke.draw_engine
)
K_LMETA
(in
pystroke.hud
)
KMOD_ALT
(in
pystroke.input_engine
)
K_F1
(in
pystroke.event_engine
)
K_LMETA
(in
pystroke.input_engine
)
KMOD_ALT
(in
pystroke.vex
)
K_F1
(in
pystroke.game_engine
)
K_LMETA
(in
pystroke.vex
)
KMOD_CAPS
(in
pystroke.draw_engine
)
K_F1
(in
pystroke.hud
)
K_LSHIFT
(in
pystroke.draw_engine
)
KMOD_CAPS
(in
pystroke.event_engine
)
K_F1
(in
pystroke.input_engine
)
K_LSHIFT
(in
pystroke.event_engine
)
KMOD_CAPS
(in
pystroke.game_engine
)
K_F1
(in
pystroke.vex
)
K_LSHIFT
(in
pystroke.game_engine
)
KMOD_CAPS
(in
pystroke.hud
)
K_F10
(in
pystroke.draw_engine
)
K_LSHIFT
(in
pystroke.hud
)
KMOD_CAPS
(in
pystroke.input_engine
)
K_F10
(in
pystroke.event_engine
)
K_LSHIFT
(in
pystroke.input_engine
)
KMOD_CAPS
(in
pystroke.vex
)
K_F10
(in
pystroke.game_engine
)
K_LSHIFT
(in
pystroke.vex
)
KMOD_CTRL
(in
pystroke.draw_engine
)
K_F10
(in
pystroke.hud
)
K_LSUPER
(in
pystroke.draw_engine
)
KMOD_CTRL
(in
pystroke.event_engine
)
K_F10
(in
pystroke.input_engine
)
K_LSUPER
(in
pystroke.event_engine
)
KMOD_CTRL
(in
pystroke.game_engine
)
K_F10
(in
pystroke.vex
)
K_LSUPER
(in
pystroke.game_engine
)
KMOD_CTRL
(in
pystroke.hud
)
K_F11
(in
pystroke.draw_engine
)
K_LSUPER
(in
pystroke.hud
)
KMOD_CTRL
(in
pystroke.input_engine
)
K_F11
(in
pystroke.event_engine
)
K_LSUPER
(in
pystroke.input_engine
)
KMOD_CTRL
(in
pystroke.vex
)
K_F11
(in
pystroke.game_engine
)
K_LSUPER
(in
pystroke.vex
)
KMOD_LALT
(in
pystroke.draw_engine
)
K_F11
(in
pystroke.hud
)
K_m
(in
pystroke.draw_engine
)
KMOD_LALT
(in
pystroke.event_engine
)
K_F11
(in
pystroke.input_engine
)
K_m
(in
pystroke.event_engine
)
KMOD_LALT
(in
pystroke.game_engine
)
K_F11
(in
pystroke.vex
)
K_m
(in
pystroke.game_engine
)
KMOD_LALT
(in
pystroke.hud
)
K_F12
(in
pystroke.draw_engine
)
K_m
(in
pystroke.hud
)
KMOD_LALT
(in
pystroke.input_engine
)
K_F12
(in
pystroke.event_engine
)
K_m
(in
pystroke.input_engine
)
KMOD_LALT
(in
pystroke.vex
)
K_F12
(in
pystroke.game_engine
)
K_m
(in
pystroke.vex
)
KMOD_LCTRL
(in
pystroke.draw_engine
)
K_F12
(in
pystroke.hud
)
K_MENU
(in
pystroke.draw_engine
)
KMOD_LCTRL
(in
pystroke.event_engine
)
K_F12
(in
pystroke.input_engine
)
K_MENU
(in
pystroke.event_engine
)
KMOD_LCTRL
(in
pystroke.game_engine
)
K_F12
(in
pystroke.vex
)
K_MENU
(in
pystroke.game_engine
)
KMOD_LCTRL
(in
pystroke.hud
)
K_F13
(in
pystroke.draw_engine
)
K_MENU
(in
pystroke.hud
)
KMOD_LCTRL
(in
pystroke.input_engine
)
K_F13
(in
pystroke.event_engine
)
K_MENU
(in
pystroke.input_engine
)
KMOD_LCTRL
(in
pystroke.vex
)
K_F13
(in
pystroke.game_engine
)
K_MENU
(in
pystroke.vex
)
KMOD_LMETA
(in
pystroke.draw_engine
)
K_F13
(in
pystroke.hud
)
K_MINUS
(in
pystroke.draw_engine
)
KMOD_LMETA
(in
pystroke.event_engine
)
K_F13
(in
pystroke.input_engine
)
K_MINUS
(in
pystroke.event_engine
)
KMOD_LMETA
(in
pystroke.game_engine
)
K_F13
(in
pystroke.vex
)
K_MINUS
(in
pystroke.game_engine
)
KMOD_LMETA
(in
pystroke.hud
)
K_F14
(in
pystroke.draw_engine
)
K_MINUS
(in
pystroke.hud
)
KMOD_LMETA
(in
pystroke.input_engine
)
K_F14
(in
pystroke.event_engine
)
K_MINUS
(in
pystroke.input_engine
)
KMOD_LMETA
(in
pystroke.vex
)
K_F14
(in
pystroke.game_engine
)
K_MINUS
(in
pystroke.vex
)
KMOD_LSHIFT
(in
pystroke.draw_engine
)
K_F14
(in
pystroke.hud
)
K_MODE
(in
pystroke.draw_engine
)
KMOD_LSHIFT
(in
pystroke.event_engine
)
K_F14
(in
pystroke.input_engine
)
K_MODE
(in
pystroke.event_engine
)
KMOD_LSHIFT
(in
pystroke.game_engine
)
K_F14
(in
pystroke.vex
)
K_MODE
(in
pystroke.game_engine
)
KMOD_LSHIFT
(in
pystroke.hud
)
K_F15
(in
pystroke.draw_engine
)
K_MODE
(in
pystroke.hud
)
KMOD_LSHIFT
(in
pystroke.input_engine
)
K_F15
(in
pystroke.event_engine
)
K_MODE
(in
pystroke.input_engine
)
KMOD_LSHIFT
(in
pystroke.vex
)
K_F15
(in
pystroke.game_engine
)
K_MODE
(in
pystroke.vex
)
KMOD_META
(in
pystroke.draw_engine
)
K_F15
(in
pystroke.hud
)
K_n
(in
pystroke.draw_engine
)
KMOD_META
(in
pystroke.event_engine
)
K_F15
(in
pystroke.input_engine
)
K_n
(in
pystroke.event_engine
)
KMOD_META
(in
pystroke.game_engine
)
K_F15
(in
pystroke.vex
)
K_n
(in
pystroke.game_engine
)
KMOD_META
(in
pystroke.hud
)
K_F2
(in
pystroke.draw_engine
)
K_n
(in
pystroke.hud
)
KMOD_META
(in
pystroke.input_engine
)
K_F2
(in
pystroke.event_engine
)
K_n
(in
pystroke.input_engine
)
KMOD_META
(in
pystroke.vex
)
K_F2
(in
pystroke.game_engine
)
K_n
(in
pystroke.vex
)
KMOD_MODE
(in
pystroke.draw_engine
)
K_F2
(in
pystroke.hud
)
K_NUMLOCK
(in
pystroke.draw_engine
)
KMOD_MODE
(in
pystroke.event_engine
)
K_F2
(in
pystroke.input_engine
)
K_NUMLOCK
(in
pystroke.event_engine
)
KMOD_MODE
(in
pystroke.game_engine
)
K_F2
(in
pystroke.vex
)
K_NUMLOCK
(in
pystroke.game_engine
)
KMOD_MODE
(in
pystroke.hud
)
K_F3
(in
pystroke.draw_engine
)
K_NUMLOCK
(in
pystroke.hud
)
KMOD_MODE
(in
pystroke.input_engine
)
K_F3
(in
pystroke.event_engine
)
K_NUMLOCK
(in
pystroke.input_engine
)
KMOD_MODE
(in
pystroke.vex
)
K_F3
(in
pystroke.game_engine
)
K_NUMLOCK
(in
pystroke.vex
)
KMOD_NONE
(in
pystroke.draw_engine
)
K_F3
(in
pystroke.hud
)
K_o
(in
pystroke.draw_engine
)
KMOD_NONE
(in
pystroke.event_engine
)
K_F3
(in
pystroke.input_engine
)
K_o
(in
pystroke.event_engine
)
KMOD_NONE
(in
pystroke.game_engine
)
K_F3
(in
pystroke.vex
)
K_o
(in
pystroke.game_engine
)
KMOD_NONE
(in
pystroke.hud
)
K_F4
(in
pystroke.draw_engine
)
K_o
(in
pystroke.hud
)
KMOD_NONE
(in
pystroke.input_engine
)
K_F4
(in
pystroke.event_engine
)
K_o
(in
pystroke.input_engine
)
KMOD_NONE
(in
pystroke.vex
)
K_F4
(in
pystroke.game_engine
)
K_o
(in
pystroke.vex
)
KMOD_NUM
(in
pystroke.draw_engine
)
K_F4
(in
pystroke.hud
)
K_p
(in
pystroke.draw_engine
)
KMOD_NUM
(in
pystroke.event_engine
)
K_F4
(in
pystroke.input_engine
)
K_p
(in
pystroke.event_engine
)
KMOD_NUM
(in
pystroke.game_engine
)
K_F4
(in
pystroke.vex
)
K_p
(in
pystroke.game_engine
)
KMOD_NUM
(in
pystroke.hud
)
K_F5
(in
pystroke.draw_engine
)
K_p
(in
pystroke.hud
)
KMOD_NUM
(in
pystroke.input_engine
)
K_F5
(in
pystroke.event_engine
)
K_p
(in
pystroke.input_engine
)
KMOD_NUM
(in
pystroke.vex
)
K_F5
(in
pystroke.game_engine
)
K_p
(in
pystroke.vex
)
KMOD_RALT
(in
pystroke.draw_engine
)
K_F5
(in
pystroke.hud
)
K_PAGEDOWN
(in
pystroke.draw_engine
)
KMOD_RALT
(in
pystroke.event_engine
)
K_F5
(in
pystroke.input_engine
)
K_PAGEDOWN
(in
pystroke.event_engine
)
KMOD_RALT
(in
pystroke.game_engine
)
K_F5
(in
pystroke.vex
)
K_PAGEDOWN
(in
pystroke.game_engine
)
KMOD_RALT
(in
pystroke.hud
)
K_F6
(in
pystroke.draw_engine
)
K_PAGEDOWN
(in
pystroke.hud
)
KMOD_RALT
(in
pystroke.input_engine
)
K_F6
(in
pystroke.event_engine
)
K_PAGEDOWN
(in
pystroke.input_engine
)
KMOD_RALT
(in
pystroke.vex
)
K_F6
(in
pystroke.game_engine
)
K_PAGEDOWN
(in
pystroke.vex
)
KMOD_RCTRL
(in
pystroke.draw_engine
)
K_F6
(in
pystroke.hud
)
K_PAGEUP
(in
pystroke.draw_engine
)
KMOD_RCTRL
(in
pystroke.event_engine
)
K_F6
(in
pystroke.input_engine
)
K_PAGEUP
(in
pystroke.event_engine
)
KMOD_RCTRL
(in
pystroke.game_engine
)
K_F6
(in
pystroke.vex
)
K_PAGEUP
(in
pystroke.game_engine
)
KMOD_RCTRL
(in
pystroke.hud
)
K_F7
(in
pystroke.draw_engine
)
K_PAGEUP
(in
pystroke.hud
)
KMOD_RCTRL
(in
pystroke.input_engine
)
K_F7
(in
pystroke.event_engine
)
K_PAGEUP
(in
pystroke.input_engine
)
KMOD_RCTRL
(in
pystroke.vex
)
K_F7
(in
pystroke.game_engine
)
K_PAGEUP
(in
pystroke.vex
)
KMOD_RMETA
(in
pystroke.draw_engine
)
K_F7
(in
pystroke.hud
)
K_PAUSE
(in
pystroke.draw_engine
)
KMOD_RMETA
(in
pystroke.event_engine
)
K_F7
(in
pystroke.input_engine
)
K_PAUSE
(in
pystroke.event_engine
)
KMOD_RMETA
(in
pystroke.game_engine
)
K_F7
(in
pystroke.vex
)
K_PAUSE
(in
pystroke.game_engine
)
KMOD_RMETA
(in
pystroke.hud
)
K_F8
(in
pystroke.draw_engine
)
K_PAUSE
(in
pystroke.hud
)
KMOD_RMETA
(in
pystroke.input_engine
)
K_F8
(in
pystroke.event_engine
)
K_PAUSE
(in
pystroke.input_engine
)
KMOD_RMETA
(in
pystroke.vex
)
K_F8
(in
pystroke.game_engine
)
K_PAUSE
(in
pystroke.vex
)
KMOD_RSHIFT
(in
pystroke.draw_engine
)
K_F8
(in
pystroke.hud
)
K_PERIOD
(in
pystroke.draw_engine
)
KMOD_RSHIFT
(in
pystroke.event_engine
)
K_F8
(in
pystroke.input_engine
)
K_PERIOD
(in
pystroke.event_engine
)
KMOD_RSHIFT
(in
pystroke.game_engine
)
K_F8
(in
pystroke.vex
)
K_PERIOD
(in
pystroke.game_engine
)
KMOD_RSHIFT
(in
pystroke.hud
)
K_F9
(in
pystroke.draw_engine
)
K_PERIOD
(in
pystroke.hud
)
KMOD_RSHIFT
(in
pystroke.input_engine
)
K_F9
(in
pystroke.event_engine
)
K_PERIOD
(in
pystroke.input_engine
)
KMOD_RSHIFT
(in
pystroke.vex
)
K_F9
(in
pystroke.game_engine
)
K_PERIOD
(in
pystroke.vex
)
KMOD_SHIFT
(in
pystroke.draw_engine
)
K_F9
(in
pystroke.hud
)
K_PLUS
(in
pystroke.draw_engine
)
KMOD_SHIFT
(in
pystroke.event_engine
)
K_F9
(in
pystroke.input_engine
)
K_PLUS
(in
pystroke.event_engine
)
KMOD_SHIFT
(in
pystroke.game_engine
)
K_F9
(in
pystroke.vex
)
K_PLUS
(in
pystroke.game_engine
)
KMOD_SHIFT
(in
pystroke.hud
)
K_FIRST
(in
pystroke.draw_engine
)
K_PLUS
(in
pystroke.hud
)
KMOD_SHIFT
(in
pystroke.input_engine
)
K_FIRST
(in
pystroke.event_engine
)
K_PLUS
(in
pystroke.input_engine
)
KMOD_SHIFT
(in
pystroke.vex
)
K_FIRST
(in
pystroke.game_engine
)
K_PLUS
(in
pystroke.vex
)
L
letters
(in
HUDText
)
LIL_ENDIAN
(in
pystroke.game_engine
)
LIL_ENDIAN
(in
pystroke.vex
)
LIL_ENDIAN
(in
pystroke.draw_engine
)
LIL_ENDIAN
(in
pystroke.hud
)
locals
(in
pystroke
)
LIL_ENDIAN
(in
pystroke.event_engine
)
LIL_ENDIAN
(in
pystroke.input_engine
)
M
main()
(in
pystroke.game
)
MOUSEBUTTONDOWN
(in
pystroke.input_engine
)
MOUSEMOTION
(in
pystroke.draw_engine
)
mouse_b_down()
(in
InputEngine
)
MOUSEBUTTONDOWN
(in
pystroke.vex
)
MOUSEMOTION
(in
pystroke.event_engine
)
mouse_b_up()
(in
InputEngine
)
MOUSEBUTTONUP
(in
pystroke.draw_engine
)
MOUSEMOTION
(in
pystroke.game_engine
)
mouse_motion()
(in
InputEngine
)
MOUSEBUTTONUP
(in
pystroke.event_engine
)
MOUSEMOTION
(in
pystroke.hud
)
MOUSEBUTTONDOWN
(in
pystroke.draw_engine
)
MOUSEBUTTONUP
(in
pystroke.game_engine
)
MOUSEMOTION
(in
pystroke.input_engine
)
MOUSEBUTTONDOWN
(in
pystroke.event_engine
)
MOUSEBUTTONUP
(in
pystroke.hud
)
MOUSEMOTION
(in
pystroke.vex
)
MOUSEBUTTONDOWN
(in
pystroke.game_engine
)
MOUSEBUTTONUP
(in
pystroke.input_engine
)
move_abs()
(in
Vex
)
MOUSEBUTTONDOWN
(in
pystroke.hud
)
MOUSEBUTTONUP
(in
pystroke.vex
)
move_rel()
(in
Vex
)
N
NOEVENT
(in
pystroke.draw_engine
)
NOFRAME
(in
pystroke.event_engine
)
NUMEVENTS
(in
pystroke.event_engine
)
NOEVENT
(in
pystroke.event_engine
)
NOFRAME
(in
pystroke.game_engine
)
NUMEVENTS
(in
pystroke.game_engine
)
NOEVENT
(in
pystroke.game_engine
)
NOFRAME
(in
pystroke.hud
)
NUMEVENTS
(in
pystroke.hud
)
NOEVENT
(in
pystroke.hud
)
NOFRAME
(in
pystroke.input_engine
)
NUMEVENTS
(in
pystroke.input_engine
)
NOEVENT
(in
pystroke.input_engine
)
NOFRAME
(in
pystroke.vex
)
NUMEVENTS
(in
pystroke.vex
)
NOEVENT
(in
pystroke.vex
)
normalised()
(in
Vector2
)
NOFRAME
(in
pystroke.draw_engine
)
NUMEVENTS
(in
pystroke.draw_engine
)
O
OPENGL
(in
pystroke.draw_engine
)
OPENGL
(in
pystroke.input_engine
)
OPENGLBLIT
(in
pystroke.game_engine
)
OPENGL
(in
pystroke.event_engine
)
OPENGL
(in
pystroke.vex
)
OPENGLBLIT
(in
pystroke.hud
)
OPENGL
(in
pystroke.game_engine
)
OPENGLBLIT
(in
pystroke.draw_engine
)
OPENGLBLIT
(in
pystroke.input_engine
)
OPENGL
(in
pystroke.hud
)
OPENGLBLIT
(in
pystroke.event_engine
)
OPENGLBLIT
(in
pystroke.vex
)
P
point_inside()
(in
Vex
)
PREALLOC
(in
pystroke.hud
)
print_input_states()
(in
EventEngine
)
PREALLOC
(in
pystroke.draw_engine
)
PREALLOC
(in
pystroke.input_engine
)
process()
(in
Behaviour
)
PREALLOC
(in
pystroke.event_engine
)
PREALLOC
(in
pystroke.vex
)
pystroke
PREALLOC
(in
pystroke.game_engine
)
print_all_states()
(in
InputEngine
)
Q
QUIT
(in
pystroke.draw_engine
)
QUIT
(in
pystroke.hud
)
QUIT_FLAG
(in
pystroke.locals
)
QUIT
(in
pystroke.event_engine
)
QUIT
(in
pystroke.input_engine
)
QUIT
(in
pystroke.game_engine
)
QUIT
(in
pystroke.vex
)
R
radius
(in
Vex
)
RESIZABLE
(in
pystroke.input_engine
)
RLEACCELOK
(in
pystroke.event_engine
)
rel_dir()
(in
Vex
)
RESIZABLE
(in
pystroke.vex
)
RLEACCELOK
(in
pystroke.game_engine
)
remove()
(in
HUD
)
RLEACCEL
(in
pystroke.draw_engine
)
RLEACCELOK
(in
pystroke.hud
)
reset()
(in
InputEngine
)
RLEACCEL
(in
pystroke.event_engine
)
RLEACCELOK
(in
pystroke.input_engine
)
reset_input()
(in
EventEngine
)
RLEACCEL
(in
pystroke.game_engine
)
RLEACCELOK
(in
pystroke.vex
)
RESIZABLE
(in
pystroke.draw_engine
)
RLEACCEL
(in
pystroke.hud
)
rotate_by_radians()
(in
Vex
)
RESIZABLE
(in
pystroke.event_engine
)
RLEACCEL
(in
pystroke.input_engine
)
rotate_to_face_point()
(in
Vex
)
RESIZABLE
(in
pystroke.game_engine
)
RLEACCEL
(in
pystroke.vex
)
run()
(in
Game
)
RESIZABLE
(in
pystroke.hud
)
RLEACCELOK
(in
pystroke.draw_engine
)
run()
(in
GameEngine
)
S
SCRAP_BMP
(in
pystroke.draw_engine
)
SCRAP_SELECTION
(in
pystroke.event_engine
)
SRCALPHA
(in
pystroke.hud
)
SCRAP_BMP
(in
pystroke.event_engine
)
SCRAP_SELECTION
(in
pystroke.game_engine
)
SRCALPHA
(in
pystroke.input_engine
)
SCRAP_BMP
(in
pystroke.game_engine
)
SCRAP_SELECTION
(in
pystroke.hud
)
SRCALPHA
(in
pystroke.vex
)
SCRAP_BMP
(in
pystroke.hud
)
SCRAP_SELECTION
(in
pystroke.input_engine
)
SRCCOLORKEY
(in
pystroke.draw_engine
)
SCRAP_BMP
(in
pystroke.input_engine
)
SCRAP_SELECTION
(in
pystroke.vex
)
SRCCOLORKEY
(in
pystroke.event_engine
)
SCRAP_BMP
(in
pystroke.vex
)
SCRAP_TEXT
(in
pystroke.draw_engine
)
SRCCOLORKEY
(in
pystroke.game_engine
)
SCRAP_CLIPBOARD
(in
pystroke.draw_engine
)
SCRAP_TEXT
(in
pystroke.event_engine
)
SRCCOLORKEY
(in
pystroke.hud
)
SCRAP_CLIPBOARD
(in
pystroke.event_engine
)
SCRAP_TEXT
(in
pystroke.game_engine
)
SRCCOLORKEY
(in
pystroke.input_engine
)
SCRAP_CLIPBOARD
(in
pystroke.game_engine
)
SCRAP_TEXT
(in
pystroke.hud
)
SRCCOLORKEY
(in
pystroke.vex
)
SCRAP_CLIPBOARD
(in
pystroke.hud
)
SCRAP_TEXT
(in
pystroke.input_engine
)
start()
(in
Game
)
SCRAP_CLIPBOARD
(in
pystroke.input_engine
)
SCRAP_TEXT
(in
pystroke.vex
)
SWITCH_FLAG
(in
pystroke.locals
)
SCRAP_CLIPBOARD
(in
pystroke.vex
)
setUp()
(in
TestAdd
)
SWSURFACE
(in
pystroke.draw_engine
)
SCRAP_PBM
(in
pystroke.draw_engine
)
setUp()
(in
TestCrossProduct
)
SWSURFACE
(in
pystroke.event_engine
)
SCRAP_PBM
(in
pystroke.event_engine
)
setUp()
(in
TestDiv
)
SWSURFACE
(in
pystroke.game_engine
)
SCRAP_PBM
(in
pystroke.game_engine
)
setUp()
(in
TestDotProduct
)
SWSURFACE
(in
pystroke.hud
)
SCRAP_PBM
(in
pystroke.hud
)
setUp()
(in
TestGetAngle
)
SWSURFACE
(in
pystroke.input_engine
)
SCRAP_PBM
(in
pystroke.input_engine
)
setUp()
(in
TestMagnitude
)
SWSURFACE
(in
pystroke.vex
)
SCRAP_PBM
(in
pystroke.vex
)
setUp()
(in
TestMul
)
SYSWMEVENT
(in
pystroke.draw_engine
)
SCRAP_PPM
(in
pystroke.draw_engine
)
setUp()
(in
TestNeg
)
SYSWMEVENT
(in
pystroke.event_engine
)
SCRAP_PPM
(in
pystroke.event_engine
)
setUp()
(in
TestNormalised
)
SYSWMEVENT
(in
pystroke.game_engine
)
SCRAP_PPM
(in
pystroke.game_engine
)
setUp()
(in
TestSubtract
)
SYSWMEVENT
(in
pystroke.hud
)
SCRAP_PPM
(in
pystroke.hud
)
setUp()
(in
TestVector2
)
SYSWMEVENT
(in
pystroke.input_engine
)
SCRAP_PPM
(in
pystroke.input_engine
)
SRCALPHA
(in
pystroke.draw_engine
)
SYSWMEVENT
(in
pystroke.vex
)
SCRAP_PPM
(in
pystroke.vex
)
SRCALPHA
(in
pystroke.event_engine
)
SCRAP_SELECTION
(in
pystroke.draw_engine
)
SRCALPHA
(in
pystroke.game_engine
)
T
test_add()
(in
TestAdd
)
test_subtract()
(in
TestSubtract
)
TestSubtract
(in
pystroke.vector2_test
)
test_cross_product()
(in
TestCrossProduct
)
TestAdd
(in
pystroke.vector2_test
)
TestVector2
(in
pystroke.vector2_test
)
test_div()
(in
TestDiv
)
TestCrossProduct
(in
pystroke.vector2_test
)
TIMER_RESOLUTION
(in
pystroke.draw_engine
)
test_dot_product()
(in
TestDotProduct
)
TestDiv
(in
pystroke.vector2_test
)
TIMER_RESOLUTION
(in
pystroke.event_engine
)
test_get_angle()
(in
TestGetAngle
)
TestDotProduct
(in
pystroke.vector2_test
)
TIMER_RESOLUTION
(in
pystroke.game_engine
)
test_magnitude()
(in
TestMagnitude
)
TestGetAngle
(in
pystroke.vector2_test
)
TIMER_RESOLUTION
(in
pystroke.hud
)
test_mul()
(in
TestMul
)
TestMagnitude
(in
pystroke.vector2_test
)
TIMER_RESOLUTION
(in
pystroke.input_engine
)
test_neg()
(in
TestNeg
)
TestMul
(in
pystroke.vector2_test
)
TIMER_RESOLUTION
(in
pystroke.vex
)
test_normalised()
(in
TestNormalised
)
TestNeg
(in
pystroke.vector2_test
)
test_str()
(in
TestVector2
)
TestNormalised
(in
pystroke.vector2_test
)
U
update()
(in
BehaviourEngine
)
USEREVENT
(in
pystroke.game_engine
)
UYVY_OVERLAY
(in
pystroke.game_engine
)
update()
(in
EventEngine
)
USEREVENT
(in
pystroke.hud
)
UYVY_OVERLAY
(in
pystroke.hud
)
update()
(in
GameEngine
)
USEREVENT
(in
pystroke.input_engine
)
UYVY_OVERLAY
(in
pystroke.input_engine
)
update()
(in
Vex
)
USEREVENT
(in
pystroke.vex
)
UYVY_OVERLAY
(in
pystroke.vex
)
USEREVENT
(in
pystroke.draw_engine
)
UYVY_OVERLAY
(in
pystroke.draw_engine
)
USEREVENT
(in
pystroke.event_engine
)
UYVY_OVERLAY
(in
pystroke.event_engine
)
V
vector2
(in
pystroke
)
VIDEOEXPOSE
(in
pystroke.draw_engine
)
VIDEORESIZE
(in
pystroke.draw_engine
)
Vector2
(in
pystroke.vector2
)
VIDEOEXPOSE
(in
pystroke.event_engine
)
VIDEORESIZE
(in
pystroke.event_engine
)
vector2_test
(in
pystroke
)
VIDEOEXPOSE
(in
pystroke.game_engine
)
VIDEORESIZE
(in
pystroke.game_engine
)
vector_between()
(in
Vex
)
VIDEOEXPOSE
(in
pystroke.hud
)
VIDEORESIZE
(in
pystroke.hud
)
vex
(in
pystroke
)
VIDEOEXPOSE
(in
pystroke.input_engine
)
VIDEORESIZE
(in
pystroke.input_engine
)
Vex
(in
pystroke.vex
)
VIDEOEXPOSE
(in
pystroke.vex
)
VIDEORESIZE
(in
pystroke.vex
)
Y
YUY2_OVERLAY
(in
pystroke.draw_engine
)
YV12_OVERLAY
(in
pystroke.draw_engine
)
YVYU_OVERLAY
(in
pystroke.draw_engine
)
YUY2_OVERLAY
(in
pystroke.event_engine
)
YV12_OVERLAY
(in
pystroke.event_engine
)
YVYU_OVERLAY
(in
pystroke.event_engine
)
YUY2_OVERLAY
(in
pystroke.game_engine
)
YV12_OVERLAY
(in
pystroke.game_engine
)
YVYU_OVERLAY
(in
pystroke.game_engine
)
YUY2_OVERLAY
(in
pystroke.hud
)
YV12_OVERLAY
(in
pystroke.hud
)
YVYU_OVERLAY
(in
pystroke.hud
)
YUY2_OVERLAY
(in
pystroke.input_engine
)
YV12_OVERLAY
(in
pystroke.input_engine
)
YVYU_OVERLAY
(in
pystroke.input_engine
)
YUY2_OVERLAY
(in
pystroke.vex
)
YV12_OVERLAY
(in
pystroke.vex
)
YVYU_OVERLAY
(in
pystroke.vex
)
_
__add__()
(in
Vector2
)
__init__()
(in
HUDText
)
__package__
(in
pystroke.game_engine
)
__div__()
(in
Vector2
)
__init__()
(in
InputEngine
)
__package__
(in
pystroke.hud
)
__init__()
(in
Behaviour
)
__init__()
(in
Vector2
)
__package__
(in
pystroke.input_engine
)
__init__()
(in
BehaviourEngine
)
__init__()
(in
Vex
)
__package__
(in
pystroke.locals
)
__init__()
(in
DrawEngine
)
__mul__()
(in
Vector2
)
__package__
(in
pystroke.vector2
)
__init__()
(in
EventEngine
)
__neg__()
(in
Vector2
)
__package__
(in
pystroke.vector2_test
)
__init__()
(in
Game
)
__package__
(in
pystroke
)
__package__
(in
pystroke.vex
)
__init__()
(in
GameEngine
)
__package__
(in
pystroke.behaviour
)
__str__()
(in
Vector2
)
__init__()
(in
HUD
)
__package__
(in
pystroke.behaviour_engine
)
__str__()
(in
Vex
)
__init__()
(in
HUDElement
)
__package__
(in
pystroke.draw_engine
)
__sub__()
(in
Vector2
)
__init__()
(in
HUDLine
)
__package__
(in
pystroke.event_engine
)
__init__()
(in
HUDPolygon
)
__package__
(in
pystroke.game
)
Home
Trees
Indices
Help
pystroke
Generated by Epydoc 3.0.1 on Wed Apr 3 20:14:21 2013
http://epydoc.sourceforge.net


Kernel Creative Media is an integrated web and marketing firm with almost two decades of experience. We listen, collaborate, and form customized solutions for you. Let us help grow your business and make it remarkable!


{%extends "base.html"%} {% block script %} {%endblock%} {% block breadcrumb %} | Make an Order {% endblock %} {%block about_this_page %}
If you don't need to update quantities then you go to the next step by clicking the {{ submit_button_text }} button.
{% if user.captain %}Click here to go back to your Captain's Page without saving changes.
{% endif %} {% if errors %}The latest changes have not been saved. Please look for the reasons in red below and try submitting again. Contact {{ help_contact }} for help.
{% endif %} {% endblock %} {%block body%} {%endblock%}


Chapter 10 Understanding data, overfitting, and p values
conceptual
statistics
machine learning
cross validation
If you’re an engineer you might not be very familar with statistical inference and p values and the point of it all might be a little mysterious. At the same time, you might be very familiar with the issue of overfitting data and using something like training and test sets, cross-validation, and other schemes to investigate data. A neuroscientist will be less familar with those instead. But it turns out that they are closely related.
This post will be short and elaborated later (hopefully). Suppose you’re an engineer and plot the data and get some 2-D data scatter plot.  But you also try a quadratic fit, a cubic fit, and even some fancy new spline method just published. It makes sense to try several methods because you don’t know the data well (you’re just studying it now). You then summarize how all of the methods behave, how well they fit the data.
The paradox is that you can’t do that in an experimental science situation. You have to decide in advance which method you want to use and only then apply it to the data. But why? Isn’t this too limiting?
The reason (this needs to be short) is that when you analyze a new dataset you usually don’t have so much data that you can try a lot of methods, pick what you like most, and then apply it to the data that you really care about. You don’t have data available like that. Because of this, if you try multiple methods you will be reporting what works best for your specific dataset which may generalize very poorly to new datasets. And what you want in general is to be able to generalize.
In the case of fit example above, perhaps the spline fit explains most of the variance in the data. But then it could be really overfitting your data and generalize very poorly to new datasets. You could find this out by testing it in a new dataset, that’s easy enough. The problem is that you don’t have data to test it with, so you’re stuck. Data are so difficult to acquire in general that this approach is usually not possible. (HCP data and other large datasets are helpful in this respect, of course.)
Bottom line: you have to find some clever way to choose all your analyses in advance. Maybe you can use similar data, maybe simulated data, or just parsimony – the simplest model possible, or the fewest assumptions.
To conclude, data analysis in an experimental setting is not a report of what happens to your data when you apply the set of most common types of fits/analyses available. It’s what happens when you apply one type of analysis to one dataset that is supposed to be representative of data in general.
Note 1: Of course, it’s always possible to perform exploratory data analysis in the context of methodological studies, but that’s different.
Note 2: I never got to how this is related to p values and statistical inference. As it’s commonly said, that’s left as an exercise for the reader…


# Copyright (c) 2021 - present / Neuralmagic, Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Helper values and classes for marshmallow schemas
"""
from typing import Any, Dict, Mapping
from marshmallow import Schema, ValidationError, fields
__all__ = [
"INSTRUCTION_SETS",
"INFERENCE_ENGINE_TYPES",
"ML_FRAMEWORKS",
"OPTIM_MODIFIER_TYPES",
"PRUNING_LOSS_ESTIMATION_TYPES",
"PRUNING_STRUCTURE_TYPES",
"QUANTIZATION_LEVELS",
"LR_CLASSES",
"FILE_SOURCES",
"MODEL_DATA_SOURCES",
"METRIC_DISPLAY_TYPES",
"data_dump_and_validation",
"EnumField",
]
INSTRUCTION_SETS = ["AVX2", "AVX512", "VNNI"]
INFERENCE_ENGINE_TYPES = ["deepsparse", "ort_cpu", "ort_gpu"]
ML_FRAMEWORKS = ["pytorch", "tensorflow"]
OPTIM_MODIFIER_TYPES = ["pruning", "quantization", "lr_schedule", "trainable"]
PRUNING_LOSS_ESTIMATION_TYPES = ["weight_magnitude", "one_shot"]
PRUNING_STRUCTURE_TYPES = ["unstructured", "block_2", "block_4", "channel", "filter"]
QUANTIZATION_LEVELS = ["int8", "int16"]
LR_CLASSES = ["set", "step", "multi_step", "exponential"]
FILE_SOURCES = ["uploaded", "generated"]
MODEL_DATA_SOURCES = ["uploaded", "downloaded_path", "downloaded_repo"]
METRIC_DISPLAY_TYPES = ["number", "percent", "scientific"]
[docs]def data_dump_and_validation(schema: Schema, data: Any) -> Dict:
"""
Use a marshmallow schema to dump and validate input data
:param schema: the schema to use to dump an object and validate it
:param data: the data to dump and validate
:return: the resulting dumped data from marshmallow
"""
val = schema.dump(data)
errors = schema.validate(val)
if errors:
raise ValidationError(errors)
return val
[docs]class EnumField(fields.String):
"""
Custom schema field for handling serializing and deserializing enums
:param enum_class: the enum class to use for deserializing
:param args: args to pass to the field
:param kwargs: the kwargs to pass to the field
"""
def __init__(self, enum_class: Any, *args, **kwargs):
self.enum_class = enum_class
super(EnumField, self).__init__(*args, **kwargs)
def _serialize(self, value: Any, attr: str, obj: Any, **kwargs):
field = super(EnumField, self)._serialize(value, attr, obj)
if not isinstance(field, str):
return field.name
if self.enum_class and self.enum_class.__name__ in field:
field = field.replace("{}.".format(self.enum_class.__name__), "")
return field
[docs] def deserialize(
self, value: Any, attr: str = None, data: Mapping[str, Any] = None, **kwargs
):
field = super(EnumField, self).deserialize(value, attr, data)
if (
isinstance(field, str)
and self.enum_class is not None
and self.enum_class.__name__ not in field
):
field = "{}.{}".format(self.enum_class.__name__, field)
return field


We strongly advise that you to read the Code of Conduct carefully.
Hackers Day Dehradun is an Non-Profitable Information Security Community for promoting,
demonstrating & spreading awareness regarding the field of Information Security which
provides a platform for open discussion between participants, where radical viewpoints
are welcome and a high degree of skepticism is expected. However, insulting or
harassing any participant is unacceptable.
We do not condone harassment against any participant, for any reason.
Harassment includes hate speeches, deliberate intimidation and targeting any
individual in a manner that makes them feel uncomfortable, sad, unwelcome, or afraid.
Any kind of harassment, hate speech, verbal abuse against our team members,
attendees and exhibitors to speakers, press and volunteers will not be accepted
and strict actions will be taken against such elements.
If you are being harassed, notice that someone else is being harassed,
or have any other concerns, you can immediately contact our team members or
send us an email at root[at]hackersdaydehradun[dot]org
,our team will be happy to help participants contact security, local law enforcement, or
otherwise assist those experiencing harassment to feel safe for the duration of Hackers Day Dehradun Events.


If you use assistive technology (such as a screen reader) and need a
version of this document in a more accessible format, please email
<EMAIL_ADDRESS>.
Please tell us what format you need. It will help us if you say what assistive technology you use.
Details
Many pupils are taking qualifications that do not provide routes to higher levels of education or the prospect of employment. Our aim is to raise standards by focusing schools on the highest quality qualifications, improving all pupils’ opportunities for progression and ensuring that vocational education is held in high esteem.
This will be achieved by reforming performance tables for 14- to 16-year-olds from 2014 (for courses undertaken from September 2012), so that they only recognise qualifications which are high quality, rigorous and provide access to a range of study and employment opportunities. All qualifications will count in performance tables as equivalent to no more than one GCSE.


Chocolate is commonly seen as an allergenic food but very few actual " allergies" to chocolate have been documented. Yet, chocolate has been blamed for a range of allergic reactions including abdominal cramps, angioedema, coughs, hypotension, itching, migraines, and urticaria.
A true intolerance or allergy to chocolate or cocoa would have to be to either the cocoa mass or the cocoa butter. Yet, when assessing problems with chocolate, these are rarely checked independently of other ingredients.
Eating a chocolate bar or drinking hot chocolate is NOT the way to test for a" chocolate" intolerance. Intolerance problems with chocolate can be caused by any ingredient or naturally occurring chemical. The ingredients that can cause problems include flavorings, milk and emulsifiers. The chemicals include caffeine and theobromine, phenylethylamine, and tyramine. An ImmunoCAP, epicutaneous or skin prick test should be taken to determine the specific source of the allergies.


SDLTRSKnown BugsIntroduction | Features | Options | Text GUI | Known Bugs | Release History | Credits |
The emulated serial port's modem status and control signals are not tied to the signals on the real serial port, because the real signals are not available to software through the Unix tty device interface. The ability to check for parity, framing, and overrun errors and receive an interrupt when one occurs is not emulated. Unix does not support 2000, 3600, or 7200 baud, so these TRS-80 data rates are remapped to 38400, 57600, and 115200 baud respectively.
Some features of the floppy disk controller are not currently emulated: Force Interrupt with condition bits 0x01, 0x02, or 0x04 is not implemented. Read Track is implemented only for DMK emulated floppies. The multiple-sector flags in Read and Write are not implemented. The timing of returned sectors is emulated only for the Read Address command, and not very accurately for JV1 or JV3. If a disk has more than one sector with the same number on a track, SDLTRS will always see the first (counting from the index hole) when reading or writing; a real machine would see the next one to come under the head depending on the current rotational position of the disk. Partially reformatting a track (which TRS-80 programs like HyperZap and Model I Super Utility do to achieve mixed density) is supported for DMK but not JV3; however, switching densities while formatting (which Model III and 4 Super Utility do) works on both DMK and JV3.
Real physical floppy disks are supported only under Linux, because the other OS's does not define a portable interface to the low-level floppy controller functionality that SDLTRS needs, or support the floppy controllers themselves. There are some limitations even under Linux: Index holes are faked, not detected on the real disk, and the timing of returned sectors is not emulated at all. Due to the limitations of PC-style floppy disk controllers, when formatting a physical floppy under SDLTRS, you cannot mix sectors of different sizes on the same track, switch densities in the middle of a track, or reformat only part of a track. However, SDLTRS can read and write to physical floppies that have already been formatted in these ways (perhaps by a real TRS-80).
The extended JV3 limit of 5802 sectors is somewhat arbitrary. It could be raised by generalizing the code to permit more than two blocks of 2901, but this does not seem too useful. 5802 sectors is already enough for a 3.5-inch HD (1.44MB) floppy, which the TRS-80 didn't support anyway. If you need more space, use emulated hard drives instead of emulated floppies with huge numbers of tracks.
XTRSHARD/DCT ignores the internal write-protected flag in hard drive images, but a hard drive image can still be effectively write protected by turning off its Unix write permission bits.
The emulator uses a heuristic to decide what format a ROM file is in. If a raw binary ROM image starts with 0x01, 0x05, or 0x22, it can be misidentified as being in a different format. This is rather unlikely to occur, as ROMs typically begin with 0xF3, the DI instruction.
If you discover other bugs, write fixes for any of these, or make any other enhancements, please let us know so that we can incorporate the changes into future releases.


|
OSAPI Plus
0.3
The Open System API for C++
|
Files | |
| file | current.cpp |
| file | current.hh [code] |
| file | defs.hh [code] |
| file | factory.cpp |
| file | factory.hh [code] |
| file | library.cpp |
| file | library.hh [code] |
| file | plan.cpp |
| file | plan.hh [code] |
| file | plan_signal.cpp |
| file | plan_signal.hh [code] |
| file | process.hh [code] |
| file | runner.cpp |
| file | runner.hh [code] |
| file | signal.cpp |
| file | signal.hh [code] |
| file | state.hh [code] |
| file | status.cpp |
| file | status.hh [code] |


| DOSE: |
17 mg |
smoked |
5-MeO-DMT |
(powder / crystals) |
I suppose we've all heard the DMT story a hundred times. Fantastic tales of being rocketed and thrust about in a roiling frenzy of zen nothingness. The experience of void, death, life and for a crucial moment that lasts but a second and yet forever at once not knowing or caring what the difference is between either.
But what is really going on here?
Is it truly perceiving the entirety of the universe at once; are we really dead during that time? Why is it that these are the likenesses we commonly draw from to describe the trip?
It seems almost paradoxical that among descriptions of the 5-MeO-DMT experience you will indeed find descriptions such as 'perception of the entire universe' along side 'perception of void and nothingness'. Everything and nothing at once forever but only for an instant. The experience challenges you to strech your imagination to its limit and one conjures up these extremities of thought in a seething explosion of cerebral activity. And it's not as though we are conscioius of such thoughts, only of the bleary fluid mush that has become our existence.
At the peak of the experience one seems to indeed enter a state of zen. The senses and mind become transfixed and the mind is emptied of content; one enters a state of near perfect focus, but focus on nothing. DMT seems to forcibly strip away anything familiar, or at least distort it beyond any recognizable form. At the peak of my strong experiences, right after exhaling the hit, the visuals become so intense that my visual field truly swirls away to blackness. Or at least blankness, for the distinction between black and white is as useless as the distinction between anything so diametrically opposite in the DMT world.
And so perhaps this is why we liken this to our preconception of what it very well might be like to experience the dead state.  Thus it is that thoughts, or at least concepts, from all branches of the human experience are triggered at once and with such ferocity as to flood our senses with everything and anything we know or sense or have sensed and remembered as well as makes us feel everything we can feel at once...angry, sad, happy, others...all at once and incredibly intense so as to make them indistinguishable from each other as all the colours together make white, which is nothing like its constituents...though seemingly more pure in some sense.
And thus what is so much mental noise any more than everything seeming as nothing, the way a crowd of many intelligent discussions sounds like a rumbling murmer of gibberish with only the odd word popping out every now and then. Fragments of recognizable speech that are so discontinous and mutually irrelevant that it may as well be that it contains no real message at all.
And therefore to the topic of death. I postulate that the 5-MeO-DMT trip is not death so much as life throttled to the limit. In such a state one is incapable of any sort of thought for all the noise, nor is one capable of interpreting the senses for all they have been warped and twisted. What more is death than the end of body and mind? When all comes to a halt, we are at death. As white is to black...one and the same.
This is only at the peak of the experience, mind you. Soon after one is still firmly in the grips of the trip, but capable of amazement and thought. There is preliminary reflection of the brief stay with eternity one has just exited, elevated mood and the very psychedelic leftovers of the trip as reality slowly starts to assemble itself and the engines start to lug back down to their usual idle. The bulk of the trip is spent here, though the impact lies in the nothing.
To those of you who have been there, this may provide some food for thought. For those of you who havent, I assure you that no trip report can truly describe the experience. The english language is such a clumsy tool and it so much requires a common frame of reference to be properly understood. For this I apologize as I have here contributed, as many others, but a tiny fragment of the trip that only begins to scratch the surface of what this substance has in hold. We do what we can :-)
Safe tripping all, I hope this finds you all well.
Komrade
P.S. - Things that are good :
Chinese Internal Martial Arts
Shpongle
Peace
Tea
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


CS 376
This is a repository of thoughts and responses from the CS 376 readings: 4/19/14: Cognitive Engineering Models [link] The paper provides a good abstract »
This is a repository of thoughts and responses from the CS 376 readings: 4/19/14: Cognitive Engineering Models [link] The paper provides a good abstract »
Informatics in Industry A repository of notes from taking a seminar series in the School of Medicine. Week 2 - Google[x] Baseline study Vikram Bajaj »
This is a proposal for 4 units of independent study under Stanford's CS199 system. Motivations I've wanted to learn iOS programming for a long time but »
We were charged with writing 5 "learnings and unlearnings" from our experiences in the course. I wanted to share my takeaways from the class and summarize »
There's a new term on the rise that describes the sort of vigilantism in the online world: digilantism - the act of crowdsourcing efforts via the »


Error in input -- please go back and check if all fields are filled and none are left to default, then resubmit - (Eg auxiliary proteins have PRESENSE specified)
If this is happening too much and it's unclear what data input is missing, an update will come shortly that shows missing data in the form. Contact Christian if it gets too annoying


{% extends 'quizard/base.html' %} {% load i18n %} {% block content %}
Enter your assignment code or school and teacher name combination to get started.


nips nips2011 nips2011-17 nips2011-17-reference knowledge-graph by maker-knowledge-mining
Source: pdf
Author: Stefano Ermon, Carla P. Gomes, Ashish Sabharwal, Bart Selman
Abstract: We propose a novel Adaptive Markov Chain Monte Carlo algorithm to compute the partition function. In particular, we show how to accelerate a ﬂat histogram sampling technique by signiﬁcantly reducing the number of “null moves” in the chain, while maintaining asymptotic convergence properties. Our experiments show that our method converges quickly to highly accurate solutions on a range of benchmark instances, outperforming other state-of-the-art methods such as IJGP, TRW, and Gibbs sampling both in run-time and accuracy. We also show how obtaining a so-called density of states distribution allows for efﬁcient weight learning in Markov Logic theories. 1
[1] Martin J Wainwright and Michael I Jordan. Graphical Models, Exponential Families, and Variational Inference. Now Publishers Inc., Hanover, MA, USA, 2008.
[2] N.N. Schraudolph and D. Kamenetsky. Efﬁcient exact inference in planar Ising models. In Proc. of NIPS-08, 2008.
[3] F. Wang and DP Landau. Efﬁcient, multiple-range random walk algorithm to calculate the density of states. Physical Review Letters, 86(10):2050–2053, 2001.
[4] M.J. Wainwright, T.S. Jaakkola, and A.S. Willsky. A new class of upper bounds on the log partition function. Information Theory, IEEE Transactions on, 51(7):2313–2335, 2005.
[5] Vibhav Gogate and Rina Dechter. SampleSearch: A Scheme that Searches for Consistent Samples. Journal of Machine Learning Research, 2:147–154, 2007.
[6] Mark Jerrum and Alistair Sinclair. The Markov chain Monte Carlo method: an approach to approximate counting and integration, pages 482–520. PWS Publishing Co., Boston, MA, USA, 1997.
[7] P. Domingos, S. Kok, H. Poon, M. Richardson, and P. Singla. Unifying logical and statistical ai. In Proc. of AAAI-06, pages 2–7, Boston, Massachusetts, 2006. AAAI Press.
[8] M. Richardson and P. Domingos. Markov logic networks. Machine Learning, 62(1):107–136, 2006.
[9] H. Poon and P. Domingos. Sound and efﬁcient inference with probabilistic and deterministic dependencies. In Proc. of AAAI-06, pages 458–463, 2006.
[10] J.S. Yedidia, W.T. Freeman, and Y. Weiss. Constructing free-energy approximations and generalized belief propagation algorithms. Information Theory, IEEE Transactions on, 51(7):2282–2312, 2005.
[11] S. Ermon, C. Gomes, and B. Selman. Computing the density of states of Boolean formulas. In Proc. of CP-2010, 2010.
[12] B. Selman, H.A. Kautz, and B. Cohen. Local search strategies for satisﬁability testing. In DIMACS Series in Discrete Mathematics and Theoretical Computer Science, 1996.
[13] C.P. Gomes, J. Hoffmann, A. Sabharwal, and B. Selman. From sampling to model counting. In Proc. of IJCAI-07, 2007.
[14] V. Gogate and R. Dechter. Approximate counting by sampling the backtrack-free search space. In Proc. of AAAI-07, pages 198–203, 2007. 9


API capstone steps
-
Create a Proof of Concept (Minimum Viable Product)
- come up with useful idea for the capstone
- find the APIs to support it
- test that the APIs are working in Ajax and that they are returning the relevant data
-
Create the Minimum Viable Product (MVP)
- create a Github repository (on the Github server) with a name like this: [name-of-the-project] + [name-of-the-used-apis] + "capstone"; the name will contain only lower case letters and dashes (-) between the words
- clone locally in order to create the local folder
- in this folder we will create a blank index.html file; styles.css file; app.js file
- in index.html will create the links to the styles.css and the app.js
- in the same folder will create an empty readme file
- follow the Thinkful course part about the wireframes and user cases
- create the html and css look and feel to the height of detail possible without javascript
- create the JS functionality (will integrate the API tests from the beginning )
-
Convert the MVP into the final product
- make the website easy to use by the visitor (3 click rule)
- make website code easy to maintain (expensive comments where necessary)
- add the necessary accessibility code
- improve the overall speed of the website
- end to end testing
- graceful error handling
- non-tech user feedback
- complete the readme file
-
Deliver


We provide tailor-made training to individuals, organisations, groups and chamas on various best practices that one needs to apply in their poultry farming project inorder to get optimum production from their flock, and consequently increase their income. In the past two (2) years, our training has directly benefited over 20,000 individuals who were either previously engaged in or started their poultry farming projects after attending our training. In so doing, we have made a direct contribution towards creation of jobs for youth and growth of the economy with reference to the agricultural sector. Our training covers both an in-depth theory and a practical-approach where participants of the training get a chance to visit one of our poultry farm for purposes of conceptualising and learning practically how all the best practices that they have learnt during the theory part is actually applied at the poultry farm. We organise this training on a frequency of atleast once a month and the training is open to any member of the public keen on venturing into poultry farming to attend
We also conduct training 'off-site' where a group of atleast 20 people who have organised themselves at their locality make a formal request to us via sms or email to forward a trainer to them to conduct training at their locality. This is deemed most crucial where the group seeks to cut down on costs of making logistical arrangements for all their members to travel to our farm for training.
We also do farm visitations where farm owners invite us to their farms to conduct training for their farm workers on their premises. This is aimed at building the capacity of these farm workers with a view of improving their performance and efficiency especially during those times they witness challenges either from diseases or such like issues. Under this package we also provide expert advice by making various recommendations to the farm owner with regard to what input they need to make to increase productivity both from their chicken / stock and also their farm workers.
Additionally, we have in recent times partnered with some public institutions mandated with offering agricultural training to the public to conduct public forums / symposiums where all members of the public are invited to interact with our experts on poultry matters and also make enquiries especially on areas they are facing challenges.
Call us/order on<PHONE_NUMBER> or visit us in Nairobi
Nemity poultry team is committed to the success of farmers in Africa. We provide quality products and services to ensure that farmers get optimal return on investment and consistent performance. We listen to our customers and continually improve on our products and services. We source our products from reliable and certified suppliers through long term partnerships.
Help
Shipping and Delivery
Return Policy
Corporate And Bulk Purchase


OpenLayers 3 Examples
Overlay example
Demonstrates overlays.
See the
overlay.js source
to see how this is done.
overlay, popup, mapquest, openaerial
Vienna