revert back to case sensitive because you cant hold A and a at the same time

src/device/output/key.go

@@ -1,73 +0,0 @@
-package output
-
-import (
-	"mayhem-party/src/device/output/key"
-
-	"github.com/micmonay/keybd_event"
-)
-
-var keyKeyToKeyBD = map[key.Key][]int{
-	key.A:      []int{keybd_event.VK_A},
-	key.B:      []int{keybd_event.VK_B},
-	key.C:      []int{keybd_event.VK_C},
-	key.D:      []int{keybd_event.VK_D},
-	key.E:      []int{keybd_event.VK_E},
-	key.F:      []int{keybd_event.VK_F},
-	key.G:      []int{keybd_event.VK_G},
-	key.H:      []int{keybd_event.VK_H},
-	key.I:      []int{keybd_event.VK_I},
-	key.J:      []int{keybd_event.VK_J},
-	key.K:      []int{keybd_event.VK_K},
-	key.L:      []int{keybd_event.VK_L},
-	key.M:      []int{keybd_event.VK_M},
-	key.N:      []int{keybd_event.VK_N},
-	key.O:      []int{keybd_event.VK_O},
-	key.P:      []int{keybd_event.VK_P},
-	key.Q:      []int{keybd_event.VK_Q},
-	key.R:      []int{keybd_event.VK_R},
-	key.S:      []int{keybd_event.VK_S},
-	key.T:      []int{keybd_event.VK_T},
-	key.U:      []int{keybd_event.VK_U},
-	key.V:      []int{keybd_event.VK_V},
-	key.W:      []int{keybd_event.VK_W},
-	key.X:      []int{keybd_event.VK_X},
-	key.Y:      []int{keybd_event.VK_Y},
-	key.Z:      []int{keybd_event.VK_Z},
-	key.AUpper: []int{keybd_event.VK_A},
-	key.BUpper: []int{keybd_event.VK_B},
-	key.CUpper: []int{keybd_event.VK_C},
-	key.DUpper: []int{keybd_event.VK_D},
-	key.EUpper: []int{keybd_event.VK_E},
-	key.FUpper: []int{keybd_event.VK_F},
-	key.GUpper: []int{keybd_event.VK_G},
-	key.HUpper: []int{keybd_event.VK_H},
-	key.IUpper: []int{keybd_event.VK_I},
-	key.JUpper: []int{keybd_event.VK_J},
-	key.KUpper: []int{keybd_event.VK_K},
-	key.LUpper: []int{keybd_event.VK_L},
-	key.MUpper: []int{keybd_event.VK_M},
-	key.NUpper: []int{keybd_event.VK_N},
-	key.OUpper: []int{keybd_event.VK_O},
-	key.PUpper: []int{keybd_event.VK_P},
-	key.QUpper: []int{keybd_event.VK_Q},
-	key.RUpper: []int{keybd_event.VK_R},
-	key.SUpper: []int{keybd_event.VK_S},
-	key.TUpper: []int{keybd_event.VK_T},
-	key.UUpper: []int{keybd_event.VK_U},
-	key.VUpper: []int{keybd_event.VK_V},
-	key.WUpper: []int{keybd_event.VK_W},
-	key.XUpper: []int{keybd_event.VK_X},
-	key.YUpper: []int{keybd_event.VK_Y},
-	key.ZUpper: []int{keybd_event.VK_Z},
-	key.N1:     []int{keybd_event.VK_1},
-	key.N1:     []int{keybd_event.VK_1},
-	key.N2:     []int{keybd_event.VK_2},
-	key.N3:     []int{keybd_event.VK_3},
-	key.N4:     []int{keybd_event.VK_4},
-	key.N5:     []int{keybd_event.VK_5},
-	key.N6:     []int{keybd_event.VK_6},
-	key.N7:     []int{keybd_event.VK_7},
-	key.N8:     []int{keybd_event.VK_8},
-	key.N9:     []int{keybd_event.VK_9},
-	key.N0:     []int{keybd_event.VK_0},
-}

src/device/output/key/char.go

@@ -1,35 +1,7 @@
 package key
 
-import "os"
-
 var (
 	charToKey = map[byte]Key{
-		'A': AUpper,
-		'B': BUpper,
-		'C': CUpper,
-		'D': DUpper,
-		'E': EUpper,
-		'F': FUpper,
-		'G': GUpper,
-		'H': HUpper,
-		'I': IUpper,
-		'J': JUpper,
-		'K': KUpper,
-		'L': LUpper,
-		'M': MUpper,
-		'N': NUpper,
-		'O': OUpper,
-		'P': PUpper,
-		'Q': QUpper,
-		'R': RUpper,
-		'S': SUpper,
-		'T': TUpper,
-		'U': UUpper,
-		'V': VUpper,
-		'W': WUpper,
-		'X': XUpper,
-		'Y': YUpper,
-		'Z': ZUpper,
 		'a': A,
 		'b': B,
 		'c': C,
@@ -84,10 +56,8 @@ func ToChar(k Key) byte {
 	return v
 }
 
-var caseSensitive = os.Getenv("CASE_SENSITIVE") != "true"
-
 func FromChar(b byte) Key {
-	if !caseSensitive && 'A' <= b && b <= 'Z' {
+	if 'A' <= b && b <= 'Z' {
 		b += 'a' - 'A'
 	}
 	v, ok := charToKey[b]

src/device/output/key/char_test.go

@@ -3,7 +3,6 @@ package key
 import "testing"
 
 func TestFromChar(t *testing.T) {
-	caseSensitive = false
 	if got := FromChar('1'); got != N1 {
 		t.Error(got)
 	}
@@ -22,11 +21,4 @@ func TestFromChar(t *testing.T) {
 	if got := ToChar(-1); got != '?' {
 		t.Error(got)
 	}
-	caseSensitive = true
-	if got := FromChar('a'); got != A {
-		t.Error(got)
-	}
-	if got := FromChar('A'); got != AUpper {
-		t.Error(got)
-	}
 }

src/device/output/key/keys.go

@@ -1,69 +1,45 @@
 package key
 
+import "github.com/micmonay/keybd_event"
+
 type Key int
 
 const (
-	Undef = iota
+	Undef = Key(keybd_event.VK_SP11)
-	A
+	A     = Key(keybd_event.VK_A)
-	B
+	B     = Key(keybd_event.VK_B)
-	C
+	C     = Key(keybd_event.VK_C)
-	D
+	D     = Key(keybd_event.VK_D)
-	E
+	E     = Key(keybd_event.VK_E)
-	F
+	F     = Key(keybd_event.VK_F)
-	G
+	G     = Key(keybd_event.VK_G)
-	H
+	H     = Key(keybd_event.VK_H)
-	I
+	I     = Key(keybd_event.VK_I)
-	J
+	J     = Key(keybd_event.VK_J)
-	K
+	K     = Key(keybd_event.VK_K)
-	L
+	L     = Key(keybd_event.VK_L)
-	M
+	M     = Key(keybd_event.VK_M)
-	N
+	N     = Key(keybd_event.VK_N)
-	O
+	O     = Key(keybd_event.VK_O)
-	P
+	P     = Key(keybd_event.VK_P)
-	Q
+	Q     = Key(keybd_event.VK_Q)
-	R
+	R     = Key(keybd_event.VK_R)
-	S
+	S     = Key(keybd_event.VK_S)
-	T
+	T     = Key(keybd_event.VK_T)
-	U
+	U     = Key(keybd_event.VK_U)
-	V
+	V     = Key(keybd_event.VK_V)
-	W
+	W     = Key(keybd_event.VK_W)
-	X
+	X     = Key(keybd_event.VK_X)
-	Y
+	Y     = Key(keybd_event.VK_Y)
-	Z
+	Z     = Key(keybd_event.VK_Z)
-	AUpper
+	N1    = Key(keybd_event.VK_1)
-	BUpper
+	N2    = Key(keybd_event.VK_2)
-	CUpper
+	N3    = Key(keybd_event.VK_3)
-	DUpper
+	N4    = Key(keybd_event.VK_4)
-	EUpper
+	N5    = Key(keybd_event.VK_5)
-	FUpper
+	N6    = Key(keybd_event.VK_6)
-	GUpper
+	N7    = Key(keybd_event.VK_7)
-	HUpper
+	N8    = Key(keybd_event.VK_8)
-	IUpper
+	N9    = Key(keybd_event.VK_9)
-	JUpper
+	N0    = Key(keybd_event.VK_0)
-	KUpper
-	LUpper
-	MUpper
-	NUpper
-	OUpper
-	PUpper
-	QUpper
-	RUpper
-	SUpper
-	TUpper
-	UUpper
-	VUpper
-	WUpper
-	XUpper
-	YUpper
-	ZUpper
-	N1
-	N2
-	N3
-	N4
-	N5
-	N6
-	N7
-	N8
-	N9
-	N0
 )

src/device/output/keyboard.go

@@ -38,9 +38,9 @@ func (kb Keyboard) Press(keys ...key.Key) {
 		return
 	}
 
-	ints := make([]int, 0, len(keys))
+	ints := make([]int, len(keys))
 	for i := range keys {
-		ints = append(ints, keyKeyToKeyBD[keys[i]]...)
+		ints[i] = int(keys[i])
 	}
 
 	kb.kb.SetKeys(ints...)