public bool Execute(JHSNetworkMessage netMsg)
        {
            if (DbManager == null)
            {
                DbManager = AccountManager.Instance;
            }

            CollectActive packet = netMsg.ReadMessage <CollectActive>();

            if (packet != null)
            {
                uint       connectionId = netMsg.conn.connectionId;
                AccountOBJ user         = DbManager.GetOnlineByConnectionId(connectionId);
                if (user != null)
                {
                    lock (user)
                    {
                        ActivesConfig model = ConfigManager.GetActive((int)packet.AciveId);
                        if (model == null)
                        {
                            netMsg.conn.Send(NetworkConstants.COLLECT_ACTIVE, new CollectActiveResponse()
                            {
                                STATUS = ITEM_CONFIG_WRONG
                            });
                            return(true);
                        }

                        ActivesOBJ active = user.GetActive((int)packet.AciveId);
                        if (active == null)
                        {
                            netMsg.conn.Send(NetworkConstants.COLLECT_ACTIVE, new CollectActiveResponse()
                            {
                                STATUS = ACTIVE_NOT_FOUND
                            });
                            return(true);
                        }

                        if (active.Collected)
                        {
                            netMsg.conn.Send(NetworkConstants.COLLECT_ACTIVE, new CollectActiveResponse()
                            {
                                STATUS = ACTIVE_ALREADY_COLLECTED
                            });
                            return(true);
                        }
                        if (model.Conditions != active.Value)
                        {
                            netMsg.conn.Send(NetworkConstants.COLLECT_ACTIVE, new CollectActiveResponse()
                            {
                                STATUS = ACTIVE_NOT_COMPLEATED
                            });
                            return(true);
                        }

                        active.Collected = true;
                        DbService.SubmitUpdate2Queue(active);

                        if (model.GoldReward > 0)
                        {
                            user.Gold += model.GoldReward;
                        }

                        if (model.SilverReward > 0)
                        {
                            user.Silver += model.SilverReward;
                        }

                        user.ResetNotification();
                        DbService.SubmitUpdate2Queue(user);

                        netMsg.conn.Send(NetworkConstants.COLLECT_ACTIVE, new CollectActiveResponse()
                        {
                            STATUS = SUCCESS, AciveId = packet.AciveId, Gold = (uint)user.Gold, Silver = (uint)user.Silver
                        });
                    }
                }
            }
            return(true);
        }
示例#2
0
        public AccountOBJ GetAccountFromDB(string username)
        {
            CHeck();
            AccountOBJ account = null;
            Users      usr     = session.QueryOver <Users>().Where(x => x.UserName == username).List().FirstOrDefault();

            if (usr != null)
            {
                account = new AccountOBJ(usr);

                IList <Characters> chars = session.QueryOver <Characters>().Where(x => x.UserId == account.Id).List();

                account.Skins = new SortedList <uint, CharacterOBJ>();

                for (int c = 0; c < chars.Count; c++)
                {
                    Characters   character = chars[c];
                    CharacterOBJ objchar   = new CharacterOBJ(character);
                    account.Skins.Add(objchar.PlayerId, objchar);
                }

                if (chars.Count == 0)
                {
                    using (ITransaction transaction = session.BeginTransaction())
                    {
                        short      skinId = Settings.randomSkins[new Random().Next(Settings.randomSkins.Length)];
                        ConfiModel model  = ConfigManager.GetModel(skinId);
                        if (model != null)
                        {
                            Characters ccc = new Characters(account.Id, skinId)
                            {
                                SkinColorId   = model.SkinColorId,
                                EyeColorId    = model.EyeColorId,
                                HairColorId   = model.HairColorId,
                                ShirtColorId  = model.ShirtColorId,
                                PantsColorId  = model.PantsColorId,
                                BootsColorId  = model.BootsColorId,
                                GlovesColorId = model.GlovesColorId
                            };
                            session.Save(ccc);
                            transaction.Commit();
                        }
                    }
                    chars = session.QueryOver <Characters>().Where(x => x.UserId == account.Id).List();
                    for (int c = 0; c < chars.Count; c++)
                    {
                        Characters   character = chars[c];
                        CharacterOBJ objchar   = new CharacterOBJ(character);

                        account.Skins.Add(objchar.PlayerId, objchar);
                    }
                }

                IList <Actives> actives    = session.QueryOver <Actives>().Where(x => x.UserId == account.Id).List();
                ActivesConfig[] allActives = ConfigManager.GetActives();

                if (allActives.Length != actives.Count)
                {
                    for (int c = 0; c < actives.Count; c++)
                    {
                        Actives    active    = actives[c];
                        ActivesOBJ objactive = new ActivesOBJ(active);
                        account.Actives.Add(objactive.ActiveId, objactive);
                    }

                    using (ITransaction transaction = session.BeginTransaction())
                    {
                        for (int a = 0; a < allActives.Length; a++)
                        {
                            ActivesConfig ac = allActives[a];
                            if (!account.Actives.ContainsKey(ac.ActiveId))
                            {
                                Actives active = new Actives
                                {
                                    UserId    = account.Id,
                                    value     = 0,
                                    ActiveId  = ac.ActiveId,
                                    collected = false
                                };

                                session.Save(active); // <-- this

                                ActivesOBJ objactive = new ActivesOBJ(active);
                                account.Actives.Add(objactive.ActiveId, objactive);
                            }
                        }
                        transaction.Commit();
                    }

                    account.Actives.Clear();
                    actives = session.QueryOver <Actives>().Where(x => x.UserId == account.Id).List();

                    for (int c = 0; c < actives.Count; c++)
                    {
                        Actives    active    = actives[c];
                        ActivesOBJ objactive = new ActivesOBJ(active);
                        account.Actives.Add(objactive.ActiveId, objactive);
                    }
                }
                else
                {
                    for (int c = 0; c < actives.Count; c++)
                    {
                        Actives    active    = actives[c];
                        ActivesOBJ objactive = new ActivesOBJ(active);
                        account.Actives.Add(objactive.ActiveId, objactive);
                    }
                }
            }
            return(account);
        }