commonFunc.go
3.08 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
package common
import (
"bytes"
"errors"
"fmt"
"github.com/garyburd/redigo/redis"
"math"
"pro2d/common/db/redisproxy"
"strconv"
"strings"
)
func GetNextRoleId() (string, error) {
relay, err := redisproxy.HGET(fmt.Sprintf(AutoIncrement, GlobalSconf.ID), "role")
if err != nil {
return "", err
}
ID, err := redis.Int64(relay, err)
if err != nil {
return "", err
}
//roleID的范围 [GlobalSconf.ID*MaxRoleNum, GlobalSconf.ID*MaxRoleNum + MaxRoleNum]
if ID-GlobalSconf.ID*MaxRoleNum >= MaxCommNum-1 {
return "", errors.New("DB_FULL")
}
relay, err = redisproxy.HINCRBY(fmt.Sprintf(AutoIncrement, GlobalSconf.ID), "role", 1)
ID, err = redis.Int64(relay, err)
if err != nil {
return "", err
}
return fmt.Sprintf("%d", ID), nil
}
func GetNextUId() (string, error) {
relay, err := redisproxy.HGET(fmt.Sprintf(AutoIncrement, GlobalSconf.ID), "uid")
if err != nil {
return "", err
}
var ID int64 = 0
if relay == nil {
ID = 90000
redisproxy.HSET(fmt.Sprintf(AutoIncrement, GlobalSconf.ID), "uid", ID)
} else {
relay, err = redisproxy.HINCRBY(fmt.Sprintf(AutoIncrement, GlobalSconf.ID), "uid", 1)
ID, err = redis.Int64(relay, err)
if err != nil {
return "", err
}
}
return fmt.Sprintf("%d", ID), nil
}
type IMapString map[string]interface{}
type IMapStringNum map[string]int32
func MapToString(params IMapString) string {
var items bytes.Buffer
for k, v := range params {
items.WriteString(k)
items.WriteString("=")
items.WriteString(fmt.Sprintf("%v", v))
items.WriteString(" ")
}
return items.String()
}
func StringToMap(items string, num bool) IMapString {
backPack := make(map[string]interface{})
for _, v := range strings.Split(items, " ") {
ii := strings.Split(v, "=")
if len(ii) < 2 {
continue
}
if num {
c, err := strconv.Atoi(ii[1])
if err != nil {
continue
}
backPack[ii[0]] = uint32(c)
} else {
backPack[ii[0]] = ii[1]
}
}
return backPack
}
func MapNumToString(params IMapStringNum) string {
var items bytes.Buffer
for k, v := range params {
items.WriteString(k)
items.WriteString("=")
items.WriteString(fmt.Sprintf("%v", v))
items.WriteString(" ")
}
return items.String()
}
func StringToMapNum(items string) IMapStringNum {
backPack := make(IMapStringNum)
for _, v := range strings.Split(items, " ") {
ii := strings.Split(v, "=")
if len(ii) < 2 {
continue
}
c, err := strconv.Atoi(ii[1])
if err != nil {
continue
}
backPack[ii[0]] = int32(c)
}
return backPack
}
func EquipmentTypToPos(typ int32) int32 {
return int32(math.Floor(float64(typ / EquipmentInterval)))
}
func EquipmentTToPos(t int) int {
switch t {
case WeaponT:
return Weapon
case MailT:
return Mail
case ShoseT:
return Shose
case NecklaceT:
return Necklace
case RingTL:
return Ring
case RingTR:
return Ring
default:
return -1
}
}
func EquipmentPosToT(pos int32, left bool) int32 {
switch pos {
case Weapon:
return WeaponT
case Mail:
return MailT
case Shose:
return ShoseT
case Necklace:
return NecklaceT
case Ring:
if left {
return RingTL
} else {
return RingTR
}
default:
return -1
}
}