Пример #1
0
func ServerConnectGateCallback(conn *GxTcpConn, msg *GxMessage) error {
	//register server
	var req ServerConnectGateReq
	err := msg.UnpackagePbmsg(&req)
	if err != nil {
		SendPbMessage(conn, false, 0, msg.GetCmd(), msg.GetSeq(), RetFail, nil)
		return err
	}

	conn.Data = make([]interface{}, len(req.Cmds))
	mutex.Lock()
	for i := 0; i < len(req.Cmds); i++ {
		//保存自己处理的消息cmd
		conn.Data[i] = req.Cmds[i]

		cmd := uint16(req.Cmds[i])
		cmdinfo, ok := CmdServers[cmd]
		if !ok {
			CmdServers[cmd] = make(ServersInfo)
			cmdinfo, _ = CmdServers[cmd]
		}
		cmdinfo[req.GetId()] = conn
	}
	mutex.Unlock()

	SendPbMessage(conn, false, 0, msg.GetCmd(), msg.GetSeq(), RetSucc, nil)
	return nil
}
Пример #2
0
func GetRoleListCallback(conn *GxTcpConn, info *LoginInfo, msg *GxMessage) {
	rdClient := PopRedisClient()
	defer PushRedisClient(rdClient)

	var req GetRoleListReq
	var rsp GetRoleListRsp
	err := msg.UnpackagePbmsg(&req)
	if err != nil {
		SendPbMessage(conn, false, msg.GetId(), msg.GetCmd(), msg.GetSeq(), RetFail, nil)
		return
	}
	if req.Info == nil || req.GetInfo().Token == nil || req.ServerId == nil {
		SendPbMessage(conn, false, msg.GetId(), msg.GetCmd(), msg.GetSeq(), RetMsgFormatError, nil)
		return
	}

	playerName := CheckToken(rdClient, req.GetInfo().GetToken())
	if playerName == "" {
		SendPbMessage(conn, false, msg.GetId(), msg.GetCmd(), msg.GetSeq(), RetTokenError, nil)
		return
	}

	player := new(Player)
	err = player.Get(rdClient, playerName)
	if err != nil {
		SendPbMessage(conn, false, msg.GetId(), msg.GetCmd(), msg.GetSeq(), RetUserNotExists, nil)
		return
	}

	ids := GetRoleList(rdClient, playerName, req.GetServerId())
	for i := 0; i < len(ids); i++ {
		id, _ := strconv.Atoi(ids[i])

		role := new(Role)
		err = role.Get(rdClient, uint32(id))
		if err != nil {
			Debug("role %d is not existst", id)
			continue
		}
		rsp.Roles = append(rsp.Roles, &RoleCommonInfo{
			Id:         proto.Uint32(role.Id),
			Name:       proto.String(role.Name),
			Level:      proto.Uint32(role.Level),
			VocationId: proto.Uint32(role.VocationId),
		})
	}

	info.PlayerName = playerName
	info.BeginTs = time.Now().Unix()
	info.ServerId = req.GetServerId()
	SaveGateLoginInfo(rdClient, info.GateId, info.ConnId, playerName)
	info.Save(rdClient)

	SendPbMessage(conn, false, msg.GetId(), msg.GetCmd(), msg.GetSeq(), RetSucc, &rsp)
}
Пример #3
0
func SelectRoleCallback(conn *GxTcpConn, info *LoginInfo, msg *GxMessage) {
	rdClient := PopRedisClient()
	defer PushRedisClient(rdClient)

	var req SelectRoleReq

	err := msg.UnpackagePbmsg(&req)
	if err != nil {
		SendPbMessage(conn, false, msg.GetId(), msg.GetCmd(), msg.GetSeq(), RetFail, nil)
		return
	}

	if req.RoleId == nil {
		SendPbMessage(conn, false, msg.GetId(), msg.GetCmd(), msg.GetSeq(), RetMsgFormatError, nil)
		return
	}

	if req.Info != nil && req.GetInfo().Token != nil {
		//重新重连
		ret := DisconnLogin(rdClient, req.GetInfo().GetToken(), info)
		if ret != RetSucc {
			SendPbMessage(conn, false, msg.GetId(), msg.GetCmd(), msg.GetSeq(), ret, nil)
			return
		}
	}

	role := new(Role)
	err = role.Get(rdClient, req.GetRoleId())
	if err != nil {
		Debug("role %d is not existst", req.GetRoleId())
		SendPbMessage(conn, false, msg.GetId(), msg.GetCmd(), msg.GetSeq(), RetRoleNotExists, nil)
		return
	}

	info.RoleId = req.GetRoleId()
	info.Save(rdClient)

	SendPbMessage(conn, false, msg.GetId(), msg.GetCmd(), msg.GetSeq(), RetSucc, &SelectRoleRsp{
		Role: &RoleCommonInfo{
			Id:         proto.Uint32(role.Id),
			Name:       proto.String(role.Name),
			Level:      proto.Uint32(role.Level),
			VocationId: proto.Uint32(role.VocationId),
			Expr:       proto.Uint64(role.Expr),
			GodValue:   proto.Uint64(role.GodValue),
			Prestige:   proto.Uint64(role.Prestige),
			Gold:       proto.Uint64(role.Gold),
			Crystal:    proto.Uint64(role.Crystal),
		},
	})

}
Пример #4
0
func ClientRawMessage(conn *GxTcpConn, msg *GxMessage) error {
	Debug("new client message, remote: %s %s", conn.Conn.RemoteAddr().String(), msg.String())

	_, server := GetServerByCmd(msg.GetCmd())
	if server == nil {
		Debug("msg is not register, remote: %s, msg: %s", conn.Conn.RemoteAddr().String(),
			msg.String())
		return errors.New("close")
	}
	msg.SetId(conn.Id)
	server.Send(msg)
	return nil
}
Пример #5
0
func (server *GxTcpServer) runConn(gxConn *GxTcpConn) {
	go gxConn.runHeartbeat()

	for {
		var msg *GxMessage = nil
		var err error

		empty := gxConn.GetProcessMsgNull()
		if empty {
			//没有消息正在处理,查找当前缓存的消息
			msg = gxConn.GetUnprocessMsg()
		}
		if msg == nil {
			//如果没有缓存的消息,则读取新信息
			msg, err = gxConn.Recv()
			if err != nil {
				server.closeConn(gxConn)
				return
			}
			if !empty {
				//如果有消息正在处理,缓存刚刚收到的消息
				Debug("client has processing message, remote: %s, msg: %s", gxConn.Conn.RemoteAddr().String(),
					msg.String())
				gxConn.SaveUnprocessMsg(msg)
				continue
			}
		}

		if msg.GetCmd() != CmdHeartbeat {
			Debug("recv buff msg, info: %s", msg.String())
		}

		if cb, ok := server.clientCmds[msg.GetCmd()]; ok {
			//消息已经被注册
			err = cb(gxConn, msg)
			if err != nil {
				//回调返回值不为空,则关闭连接
				server.closeConn(gxConn)
				return
			}
			continue
		}

		//消息没有被注册
		err = server.Rm(gxConn, msg)
		if err != nil {
			server.closeConn(gxConn)
			return
		}
	}
}
Пример #6
0
func (conn *GxTcpConn) SaveProcessMsg(msg *GxMessage) {
	if !conn.MessageCtrl {
		return
	}

	conn.mutex.Lock()
	defer conn.mutex.Unlock()

	//服务端发送的通知seq为0
	if msg.GetMask(MessageMaskNotify) {
		return
	}

	if conn.msg == nil {
		conn.msg = msg
	} else {
		if conn.msg.GetSeq() == msg.GetSeq() && conn.msg.GetCmd() == msg.GetCmd() {
			conn.msg = nil
		}
	}

}
Пример #7
0
func CreateRoleCallback(conn *GxTcpConn, info *LoginInfo, msg *GxMessage) {
	rdClient := PopRedisClient()
	defer PushRedisClient(rdClient)

	var req CreateRoleReq

	err := msg.UnpackagePbmsg(&req)
	if err != nil {
		SendPbMessage(conn, false, msg.GetId(), msg.GetCmd(), msg.GetSeq(), RetFail, nil)
		return
	}

	if req.Name == nil || req.VocationId == nil {
		SendPbMessage(conn, false, msg.GetId(), msg.GetCmd(), msg.GetSeq(), RetMsgFormatError, nil)
		return
	}

	if req.Info != nil && req.GetInfo().Token != nil {
		//重新重连
		ret := DisconnLogin(rdClient, req.GetInfo().GetToken(), info)
		if ret != RetSucc {
			SendPbMessage(conn, false, msg.GetId(), msg.GetCmd(), msg.GetSeq(), ret, nil)
			return
		}
	}

	ids := GetRoleList(rdClient, info.PlayerName, info.ServerId)
	if len(ids) > 0 {
		SendPbMessage(conn, false, msg.GetId(), msg.GetCmd(), msg.GetSeq(), RetRoleExists, nil)
		return
	}

	if CheckRoleNameConflict(rdClient, req.GetName()) {
		SendPbMessage(conn, false, msg.GetId(), msg.GetCmd(), msg.GetSeq(), RetRoleNameConflict, nil)
		return
	}

	role := &Role{
		Id:           NewRoleID(rdClient),
		PlayerName:   info.PlayerName,
		GameServerId: info.ServerId,
		Name:         req.GetName(),
		VocationId:   req.GetVocationId(),
		Level:        0,
		Expr:         0,
		GodValue:     0,
		Prestige:     0,
		Gold:         10000,
		Crystal:      0,
	}
	role.Save(rdClient)
	SaveRoleName(rdClient, role.Name)
	//
	info.RoleId = role.Id
	info.Save(rdClient)
	//
	SendPbMessage(conn, false, msg.GetId(), msg.GetCmd(), msg.GetSeq(), RetSucc, &CreateRoleRsp{
		Role: &RoleCommonInfo{
			Id:         proto.Uint32(role.Id),
			Name:       proto.String(role.Name),
			Level:      proto.Uint32(role.Level),
			VocationId: proto.Uint32(role.VocationId),
			Expr:       proto.Uint64(role.Expr),
			GodValue:   proto.Uint64(role.GodValue),
			Prestige:   proto.Uint64(role.Prestige),
			Gold:       proto.Uint64(role.Gold),
			Crystal:    proto.Uint64(role.Crystal),
		},
	})
}