func (pm *placeMine) Respond(gid game.Gid, group gin.EventGroup) bool {
if found, event := group.FindEvent(gin.AnySpace); found && event.Type == gin.Press {
pm.fire++
return true
}
return false
}
func (rw *riftWalk) Respond(gid game.Gid, group gin.EventGroup) bool {
if found, event := group.FindEvent(gin.AnySpace); found && event.Type == gin.Press {
rw.trigger = true
return true
}
return false
}
func (l *LocalData) handleEventGroupArchitect(group gin.EventGroup) {
keys := []gin.KeyId{gin.AnyKey1, gin.AnyKey2, gin.AnyKey3, gin.AnyKey4, gin.AnyKey5, gin.AnyKey6, gin.AnyKey7, gin.AnyKey8, gin.AnyKey9}
for i := range l.architect.abs.abilities {
if found, event := group.FindEvent(keys[i]); found && event.Type == gin.Press {
l.activateAbility(&l.architect.abs, "", i, true)
}
}
if l.architect.abs.activeAbility != nil {
l.architect.abs.activeAbility.Respond("", group)
}
}
func (l *LocalData) handleEventGroupInvaders(group gin.EventGroup) {
if l.mode != LocalModeMoba {
panic("Need to implement controls for multiple players on a single screen")
}
k0 := gin.In().GetKeyFlat(gin.Key6, gin.DeviceTypeKeyboard, gin.DeviceIndexAny)
k1 := gin.In().GetKeyFlat(gin.Key7, gin.DeviceTypeKeyboard, gin.DeviceIndexAny)
k2 := gin.In().GetKeyFlat(gin.Key8, gin.DeviceTypeKeyboard, gin.DeviceIndexAny)
k3 := gin.In().GetKeyFlat(gin.Key9, gin.DeviceTypeKeyboard, gin.DeviceIndexAny)
if found, event := group.FindEvent(k0.Id()); found {
l.activateAbility(&l.moba.currentPlayer.abs, l.moba.currentPlayer.gid, 0, event.Type == gin.Press)
return
}
if found, event := group.FindEvent(k1.Id()); found {
l.activateAbility(&l.moba.currentPlayer.abs, l.moba.currentPlayer.gid, 1, event.Type == gin.Press)
return
}
if found, event := group.FindEvent(k2.Id()); found {
l.activateAbility(&l.moba.currentPlayer.abs, l.moba.currentPlayer.gid, 2, event.Type == gin.Press)
return
}
if found, event := group.FindEvent(k3.Id()); found {
l.activateAbility(&l.moba.currentPlayer.abs, l.moba.currentPlayer.gid, 3, event.Type == gin.Press)
return
}
if l.moba.currentPlayer.abs.activeAbility != nil {
if l.moba.currentPlayer.abs.activeAbility.Respond(l.moba.currentPlayer.gid, group) {
return
}
}
}
func (b *Button) Respond(eventGroup gin.EventGroup) {
// Only respond to mouse events if the mouse is hovering over the button
if !b.Hover && eventGroup.Events[0].Key.Id().Device.Type == gin.DeviceTypeMouse {
return
}
if found, event := eventGroup.FindEvent(gin.AnyMouseLButton); found && event.Type == gin.Press {
if b.Callback != nil {
b.Callback()
}
return
}
for trigger := range b.Triggers {
if found, event := eventGroup.FindEvent(trigger); found && event.Type == gin.Press {
if b.Callback != nil {
b.Callback()
}
return
}
}
}
func (game *Game) HandleEventGroupSetup(group gin.EventGroup) {
if found, event := group.FindEvent(control.hat.up.Id()); found && event.Type == gin.Press {
game.Setup.local.Lock()
defer game.Setup.local.Unlock()
if game.Setup.local.Index > 0 {
game.Setup.local.Index--
}
return
}
if found, event := group.FindEvent(control.hat.down.Id()); found && event.Type == gin.Press {
game.Setup.local.Lock()
defer game.Setup.local.Unlock()
if game.Setup.local.Index < len(game.Setup.EngineIds) {
game.Setup.local.Index++
}
return
}
if found, event := group.FindEvent(control.hat.left.Id()); found && event.Type == gin.Press {
game.local.Engine.ApplyEvent(SetupChampSelect{game.local.Engine.Id(), -1})
return
}
if found, event := group.FindEvent(control.hat.right.Id()); found && event.Type == gin.Press {
game.local.Engine.ApplyEvent(SetupChampSelect{game.local.Engine.Id(), 1})
return
}
if found, event := group.FindEvent(control.hat.enter.Id()); found && event.Type == gin.Press {
game.Setup.local.Lock()
defer game.Setup.local.Unlock()
if game.Setup.local.Index < len(game.Setup.EngineIds) {
id := game.Setup.EngineIds[game.Setup.local.Index]
side := (game.Setup.Players[id].Side + 1) % 2
game.local.Engine.ApplyEvent(SetupChangeSides{id, side})
} else {
if game.local.Engine.Id() == game.Manager || game.local.Engine.IsHost() {
game.local.Engine.ApplyEvent(SetupComplete{time.Now().UnixNano()})
}
}
return
}
}
func (tsm *ThunderSubMenu) Respond(eventGroup gin.EventGroup) {
var up, down bool
for _, keyIndex := range tsm.downs {
id := gin.In().GetKeyFlat(keyIndex, gin.DeviceTypeAny, gin.DeviceIndexAny).Id()
if found, event := eventGroup.FindEvent(id); found && event.Type == gin.Press {
down = true
}
}
for _, keyIndex := range tsm.ups {
id := gin.In().GetKeyFlat(keyIndex, gin.DeviceTypeAny, gin.DeviceIndexAny).Id()
if found, event := eventGroup.FindEvent(id); found && event.Type == gin.Press {
up = true
}
}
if down {
tsm.selected++
}
if up {
if tsm.selected == -1 {
tsm.selected = len(tsm.Options) - 1
} else {
tsm.selected--
}
}
if tsm.selected >= len(tsm.Options) || tsm.selected < 0 {
tsm.selected = -1
}
if eventGroup.Events[0].Key.Id().Device.Type != gin.DeviceTypeMouse {
if tsm.selected >= 0 && tsm.selected < len(tsm.Options) {
tsm.Options[tsm.selected].Respond(eventGroup)
}
} else {
for _, option := range tsm.Options {
option.Respond(eventGroup)
}
}
}
func (g *Game) HandleEventGroupEditor(group gin.EventGroup) {
g.editor.Lock()
defer g.editor.Unlock()
if found, event := group.FindEvent(control.editor.Id()); found && event.Type == gin.Press {
// Can't call editor.Toggle() here because we already hold the lock.
g.editor.active = false
g.editor.action = editorActionNone
return
}
if found, event := group.FindEvent(gin.AnyKeyB); found && event.Type == gin.Press {
g.editor.placeBlockAction()
return
}
if found, event := group.FindEvent(gin.AnyKeyS); found && event.Type == gin.Press {
g.editor.saveAction(&g.Level.Room)
return
}
if found, event := group.FindEvent(gin.AnyKeyP); found && event.Type == gin.Press {
g.editor.pathingAction()
return
}
switch g.editor.action {
case editorActionNone:
return
case editorActionPlaceBlock:
if found, event := group.FindEvent(gin.AnyMouseLButton); found && event.Type == gin.Press {
g.editor.placeBlockDo(g)
return
}
}
}
func (g *Game) HandleEventGroupGame(group gin.EventGroup) {
g.local.RLock()
defer g.local.RUnlock()
if found, event := group.FindEvent(control.editor.Id()); found && event.Type == gin.Press {
g.editor.Toggle()
return
}
if found, _ := group.FindEvent(control.any.Id()); found {
dir := getControllerDirection(gin.DeviceId{gin.DeviceTypeController, gin.DeviceIndexAny})
g.local.Engine.ApplyEvent(&Move{
Gid: g.local.Gid,
Angle: dir.Angle(),
Magnitude: dir.Mag(),
})
}
// ability0Key := gin.In().GetKeyFlat(gin.ControllerButton0+2, gin.DeviceTypeController, gin.DeviceIndexAny)
// abilityTrigger := gin.In().GetKeyFlat(gin.ControllerButton0+1, gin.DeviceTypeController, gin.DeviceIndexAny)
buttons := []gin.Key{
gin.In().GetKeyFlat(gin.ControllerButton0+2, gin.DeviceTypeController, gin.DeviceIndexAny),
gin.In().GetKeyFlat(gin.ControllerButton0+3, gin.DeviceTypeController, gin.DeviceIndexAny),
gin.In().GetKeyFlat(gin.ControllerButton0+4, gin.DeviceTypeController, gin.DeviceIndexAny),
gin.In().GetKeyFlat(gin.ControllerButton0+5, gin.DeviceTypeController, gin.DeviceIndexAny),
}
abilityTrigger := gin.In().GetKeyFlat(gin.ControllerButton0+6, gin.DeviceTypeController, gin.DeviceIndexAny)
for i, button := range buttons {
foundButton, _ := group.FindEvent(button.Id())
foundTrigger, triggerEvent := group.FindEvent(abilityTrigger.Id())
// TODO: Check if any abilities are Active before sending events to other abilities.
if foundButton || foundTrigger {
g.local.Engine.ApplyEvent(UseAbility{
Gid: g.local.Gid,
Index: i,
Button: button.CurPressAmt(),
Trigger: foundTrigger && triggerEvent.Type == gin.Press,
})
}
}
}