コード例 #1
0
        public async Task <IActionResult> Create(UnionMemberViewModel viewModel)
        {
            if (ModelState.IsValid)
            {
                var model   = new UnionMember(viewModel);
                var webRoot = _env.WebRootPath;
                if (viewModel.Picture != null)
                {
                    Tuple <bool, string> result = await _spiikService.SaveFile(viewModel.Picture, "images/unionmembers", viewModel.Name);

                    if (result.Item1)                                 // Success saving
                    {
                        if (!string.IsNullOrWhiteSpace(result.Item2)) // Spara endast om en bild har blivit uppladdad.
                        {
                            model.PictureSrc = result.Item2;
                        }
                    }
                    else
                    {
                        ModelState.AddModelError("Picture", result.Item2);
                        return(View());
                    }
                }
                await _db.AddAsync(model);

                await _db.SaveChangesAsync();

                TempData["Message"] = "Medlem skapad!";
                return(RedirectToAction("Index"));
            }
            return(View());
        }
コード例 #2
0
 public UnionMemberViewModel(UnionMember model)
 {
     Id         = model.Id;
     Name       = model.Name;
     Title      = model.Title;
     Email      = model.Email;
     Phone      = model.Phone;
     Quote      = model.Quote;
     PictureSrc = model.PictureSrc;
     UnionTypes = model.UnionTypes;
 }
コード例 #3
0
        public decimal UnionFeeRepayment(UnionMember unionMember)
        {
            if (unionMember == UnionMember.Yes)
            {
                unionFeeRepaymentAmount = 10m;
            }
            else
            {
                unionFeeRepaymentAmount = 0;
            }

            return(unionFeeRepaymentAmount);
        }
コード例 #4
0
 private UnionMember ReadUnionMember(DbDataReader reader)
 {
     {
         UnionMember unionMember = new UnionMember();
         unionMember.id                      = GetInt32(reader, "id");
         unionMember.unionId                 = GetInt32(reader, "union_id");
         unionMember.characterDatabaseId     = GetInt32(reader, "character_id");
         unionMember.memberPriviledgeBitMask = (uint)GetInt32(reader, "member_priviledge_bitmask");
         unionMember.rank                    = (uint)GetInt32(reader, "rank");
         unionMember.joined                  = GetDateTime(reader, "joined");
         return(unionMember);
     }
 }
コード例 #5
0
        public bool UpdateUnionMember(UnionMember unionMember)
        {
            int rowsAffected = ExecuteNonQuery(SQL_UPDATE_UNION_MEMBER, command =>
            {
                AddParameter(command, "@id", unionMember.id);
                AddParameter(command, "@union_id", unionMember.unionId);
                AddParameter(command, "@character_id", unionMember.characterDatabaseId);
                AddParameter(command, "@member_priviledge_bitmask", unionMember.memberPriviledgeBitMask);
                AddParameter(command, "@rank", unionMember.rank);
                AddParameter(command, "@joined", unionMember.joined);
            });

            return(rowsAffected > NO_ROWS_AFFECTED);
        }
コード例 #6
0
        public UnionMember SelectUnionMemberByCharacterId(int characterDatabaseId)
        {
            UnionMember unionMember = null;

            ExecuteReader(SQL_SELECT_UNION_MEMBER_BY_CHARACTER_ID,
                          command => { AddParameter(command, "@character_id", characterDatabaseId); }, reader =>
            {
                if (reader.Read())
                {
                    unionMember = ReadUnionMember(reader);
                }
            });
            return(unionMember);
        }
コード例 #7
0
        public override void Handle(NecClient client, NecPacket packet)
        {
            uint previousLeaderCharacterInstanceId =
                packet.Data.ReadUInt32();                     //Old Leader Instance ID if changing leader. otherwise 0
            uint targetInstanceId = packet.Data.ReadUInt32();
            uint targetRole       = packet.Data.ReadUInt32(); //3 beginer, 2 member, 1 sub-leader, 0 leader

            NecClient   targetClient    = Server.Clients.GetByCharacterInstanceId(targetInstanceId);
            Character   targetCharacter = Server.Characters.GetByCharacterInstanceId(targetInstanceId);
            UnionMember unionMember     = Server.Database.SelectUnionMemberByCharacterId(targetCharacter.Id);
            uint        previousRank    = unionMember.Rank;

            unionMember.Rank = targetRole;
            Server.Database.UpdateUnionMember(unionMember);

            IBuffer res = BufferProvider.Provide();

            res.WriteInt32(0); //error check
            Router.Send(client, (ushort)MsgPacketId.recv_union_request_change_role_r, res, ServerType.Msg);


            IBuffer res2 = BufferProvider.Provide();

            res2.WriteUInt32(targetInstanceId);
            res2.WriteUInt32(previousLeaderCharacterInstanceId);
            res2.WriteUInt32(targetRole);
            if (targetClient != null)
            {
                Router.Send(targetClient, (ushort)MsgPacketId.recv_union_notify_changed_role, res2, ServerType.Msg);
            }

            if (previousLeaderCharacterInstanceId > 0)
            {
                NecClient oldLeaderClient    = Server.Clients.GetByCharacterInstanceId(previousLeaderCharacterInstanceId);
                Character oldLeaderCharacter =
                    Server.Characters.GetByCharacterInstanceId(previousLeaderCharacterInstanceId);
                UnionMember oldLeaderMember = Server.Database.SelectUnionMemberByCharacterId(oldLeaderCharacter.Id);
                oldLeaderMember.Rank = previousRank;
                Server.Database.UpdateUnionMember(oldLeaderMember);
                IBuffer res3 = BufferProvider.Provide();
                res3.WriteUInt32(targetInstanceId);
                res3.WriteUInt32(previousLeaderCharacterInstanceId);
                res3.WriteUInt32(targetRole);
                if (oldLeaderClient != null)
                {
                    Router.Send(oldLeaderClient, (ushort)MsgPacketId.recv_union_notify_changed_role, res3,
                                ServerType.Msg);
                }
            }
        }
コード例 #8
0
        public bool UpdateUnionMember(UnionMember unionMember)
        {
            int rowsAffected = ExecuteNonQuery(SqlUpdateUnionMember, command =>
            {
                AddParameter(command, "@id", unionMember.Id);
                AddParameter(command, "@union_id", unionMember.UnionId);
                AddParameter(command, "@character_id", unionMember.CharacterDatabaseId);
                AddParameter(command, "@member_priviledge_bitmask", unionMember.MemberPriviledgeBitMask);
                AddParameter(command, "@rank", unionMember.Rank);
                AddParameter(command, "@joined", unionMember.Joined);
            });

            return(rowsAffected > NoRowsAffected);
        }
コード例 #9
0
        public UnionMember SelectUnionMemberByCharacterId(int CharacterDatabaseId)
        {
            UnionMember unionMember = null;

            ExecuteReader(SqlSelectUnionMemberByCharacterId,
                          command => { AddParameter(command, "@character_id", CharacterDatabaseId); }, reader =>
            {
                if (reader.Read())
                {
                    unionMember = ReadUnionMember(reader);
                }
            });
            return(unionMember);
        }
コード例 #10
0
        public List <UnionMember> SelectUnionMembersByUnionId(int unionId)
        {
            List <UnionMember> unionMembers = new List <UnionMember>();

            ExecuteReader(SQL_SELECT_UNION_MEMBERS_BY_UNION_ID,
                          command => { AddParameter(command, "@union_id", unionId); }, reader =>
            {
                while (reader.Read())
                {
                    UnionMember unionMember = ReadUnionMember(reader);
                    unionMembers.Add(unionMember);
                }
            });
            return(unionMembers);
        }
コード例 #11
0
        public bool InsertUnionMember(UnionMember unionMember)
        {
            int rowsAffected = ExecuteNonQuery(SQL_INSERT_UNION_MEMBER, command =>
            {
                //AddParameter(command, "@id", unionMember.Id);
                AddParameter(command, "@union_id", unionMember.unionId);
                AddParameter(command, "@character_id", unionMember.characterDatabaseId);
                AddParameter(command, "@member_priviledge_bitmask", unionMember.memberPriviledgeBitMask);
                AddParameter(command, "@rank", unionMember.rank);
                AddParameter(command, "@joined", unionMember.joined);
            }, out long autoIncrement);

            if (rowsAffected <= NO_ROWS_AFFECTED || autoIncrement <= NO_AUTO_INCREMENT)
            {
                return(false);
            }

            unionMember.id = (int)autoIncrement;
            return(true);
        }
コード例 #12
0
        public bool InsertUnionMember(UnionMember unionMember)
        {
            int rowsAffected = ExecuteNonQuery(SqlInsertUnionMember, command =>
            {
                //AddParameter(command, "@id", unionMember.Id);
                AddParameter(command, "@union_id", unionMember.UnionId);
                AddParameter(command, "@character_id", unionMember.CharacterDatabaseId);
                AddParameter(command, "@member_priviledge_bitmask", unionMember.MemberPriviledgeBitMask);
                AddParameter(command, "@rank", unionMember.Rank);
                AddParameter(command, "@joined", unionMember.Joined);
            }, out long autoIncrement);

            if (rowsAffected <= NoRowsAffected || autoIncrement <= NoAutoIncrement)
            {
                return(false);
            }

            unionMember.Id = (int)autoIncrement;
            return(true);
        }
コード例 #13
0
        public override void Handle(NecClient client, NecPacket packet)
        {
            UnionMember unionMember = server.database.SelectUnionMemberByCharacterId(client.character.id);

            if (unionMember == null)
            {
                _Logger.Debug("you don't appear to be in a union");
            }
            else
            {
                _Logger.Debug($"union member ID{unionMember.id} found. loading Union information");
                Union myUnion = server.database.SelectUnionById(unionMember.unionId);

                if (myUnion == null)
                {
                    _Logger.Error($"This is Strange.. Can't find a Union with id {unionMember.unionId}");
                }
                else
                {
                    _Logger.Debug($"union  ID{unionMember.unionId} found. continuing loading of Union information");

                    client.character.unionId = myUnion.id;
                    client.union             = myUnion;
                    client.union.Join(client);

                    TimeSpan differenceCreated       = client.union.created.ToUniversalTime() - DateTime.UnixEpoch;
                    int      unionCreatedCalculation = (int)Math.Floor(differenceCreated.TotalSeconds);

                    //To-Do,  move this whole thing to a response packet, since it's used multiple places.
                    //Notify client of each union member in above union, queried by charaname and InstanceId (for menu based interactions)
                    foreach (UnionMember unionMemberList in server.database.SelectUnionMembersByUnionId(client.character
                                                                                                        .unionId))
                    {
                        int       onlineStatus = 1;
                        Character character    = null;
                        Soul      soul         = null;
                        NecClient otherClient  = server.clients.GetByCharacterId(unionMemberList.characterDatabaseId);
                        if (otherClient == null)
                        {
                            character = server.instances.GetCharacterByDatabaseId(unionMemberList.characterDatabaseId);
                            soul      = server.database.SelectSoulById(character.soulId);
                        }
                        else
                        {
                            character    = otherClient.character;
                            soul         = otherClient.soul;
                            onlineStatus = 0;
                        }

                        if (character == null)
                        {
                            continue;
                        }
                        if (soul == null)
                        {
                            continue;
                        }

                        TimeSpan differenceJoined       = unionMemberList.joined.ToUniversalTime() - DateTime.UnixEpoch;
                        int      unionJoinedCalculation = (int)Math.Floor(differenceJoined.TotalSeconds);
                        IBuffer  res3 = BufferProvider.Provide();
                        res3.WriteInt32(client.character.unionId);        //Union Id
                        res3.WriteUInt32(character.instanceId);           //unique Identifier of the member in the union roster.
                        res3.WriteFixedString($"{soul.name}", 0x31);      //size is 0x31
                        res3.WriteFixedString($"{character.name}", 0x5B); //size is 0x5B
                        res3.WriteUInt32(character.classId);
                        res3.WriteByte(character.level);
                        res3.WriteByte(0);                                           //new

                        res3.WriteInt32(character.mapId);                            // Location of your Union Member
                        res3.WriteInt32(unionJoinedCalculation);                     //Area of Map, somehow. or Channel;
                        res3.WriteFixedString($"Channel {character.channel}", 0x61); // Channel location
                        res3.WriteUInt32(unionMemberList.memberPriviledgeBitMask);   //permissions bitmask  obxxxx1 = invite | obxxx1x = kick | obxx1xx = News | 0bxx1xxxxx = General Storage | 0bx1xxxxxx = Deluxe Storage
                        res3.WriteByte(0);                                           //new
                        res3.WriteUInt32(unionMemberList.rank);                      //Rank  3 = beginner 2 = member, 1 = sub-leader 0 = leader
                        res3.WriteInt32(onlineStatus);                               //online status. 0 = online, 1 = offline, 2 = away
                        res3.WriteInt32(unionJoinedCalculation);                     //Date Joined in seconds since unix time
                        res3.WriteInt32(Util.GetRandomNumber(0, 0));
                        res3.WriteInt32(Util.GetRandomNumber(0, 0));
                        res3.WriteInt32(Util.GetRandomNumber(0, 0));       //new
                        res3.WriteFixedString($"{character.name}", 0x181); //size is 0x181, new

                        router.Send(client, (ushort)MsgPacketId.recv_union_notify_detail_member, res3, ServerType.Msg);
                    }

                    uint unionLeaderInstanceId     = server.instances.GetCharacterInstanceId(myUnion.leaderId);
                    uint unionSubLeader1InstanceId = server.instances.GetCharacterInstanceId(myUnion.subLeader1Id);
                    uint unionSubLeader2InstanceId = server.instances.GetCharacterInstanceId(myUnion.subLeader2Id);

                    //Notify client if msg server found Union settings in database(memory) for client character Unique Persistant ID.
                    IBuffer res = BufferProvider.Provide();
                    res.WriteInt32(unionMember.unionId);        //Union Instance ID //form the ToDo Logic above
                    res.WriteFixedString(myUnion.name, 0x31);   //size is 0x31
                    res.WriteInt32(unionCreatedCalculation);    //Creation Date in seconds since unix 0 time (Jan. 1, 1970)
                    res.WriteUInt32(unionLeaderInstanceId);     //Leader
                    res.WriteInt32(unionCreatedCalculation);    //Last login timestamp for demoting?
                    res.WriteUInt32(unionSubLeader1InstanceId); //subleader1
                    res.WriteInt32(unionCreatedCalculation);    //Last login timestamp for demoting?
                    res.WriteUInt32(unionSubLeader2InstanceId); //subleader2
                    res.WriteInt32(unionCreatedCalculation);    //Last login timestamp for demoting?
                    res.WriteByte((byte)myUnion.level);         //Union Level
                    res.WriteUInt32(myUnion.currentExp);        //Union EXP Current
                    res.WriteUInt32(myUnion.nextLevelExp);      //Union EXP next level Target
                    res.WriteByte(myUnion.memberLimitIncrease); //Increase Union Member Limit above default 50 (See Union Bonuses
                    res.WriteByte(1);                           //?
                    res.WriteInt32(10);                         //Creation Date?
                    res.WriteInt16(myUnion.capeDesignId);       //Mantle/Cape
                    res.WriteFixedString($"You are all members of {myUnion.name} now.  Welcome!",
                                         0x196);                //size is 0x196
                    for (int i = 0; i < 8; i++)
                    {
                        res.WriteInt32(i);
                    }
                    res.WriteByte(255);
                    res.WriteInt32(0);

                    res.WriteInt32(0);
                    res.WriteInt32(0);
                    res.WriteInt32(0);
                    res.WriteInt32(0);

                    router.Send(client, (ushort)MsgPacketId.recv_union_notify_detail, res, ServerType.Msg);
                }
            }

            //Acknowledge send.  'Hey send,  i'm finished doing my stuff.  go do the next stuff'
            IBuffer res2 = BufferProvider.Provide();

            res2.WriteInt32(0);
            router.Send(client, (ushort)MsgPacketId.recv_union_request_detail_r, res2, ServerType.Msg);
        }
コード例 #14
0
        public override void Handle(NecClient client, NecPacket packet)
        {
            uint      replyToInstanceId  = packet.data.ReadUInt32();
            uint      resultAcceptOrDeny = packet.data.ReadUInt32();
            NecClient replyToClient      = server.clients.GetByCharacterInstanceId(replyToInstanceId);

            _Logger.Debug(
                $"replyToInstanceId {replyToInstanceId} resultAcceptOrDeny {resultAcceptOrDeny} replyToClient.Character.unionId {replyToClient.character.unionId}");

            //Union myUnion = Server.Instances.GetInstance(replyToClient.Character.unionId) as Union;
            Union myUnion = server.database.SelectUnionById(replyToClient.character.unionId);

            _Logger.Debug($"my union is {myUnion.name}");

            IBuffer res5 = BufferProvider.Provide();

            res5.WriteUInt32(resultAcceptOrDeny);          //Result
            res5.WriteUInt32(client.character.instanceId); //object id | Instance ID
            router.Send(replyToClient, (ushort)MsgPacketId.recv_union_reply_to_invite_r, res5, ServerType.Msg);

            if (resultAcceptOrDeny == 0)
            {
                client.character.unionId = myUnion.id;
                client.union             = myUnion;
                client.union.Join(client);

                UnionMember myUnionMember = new UnionMember();
                server.instances.AssignInstance(myUnionMember);
                myUnionMember.unionId             = myUnion.id;
                myUnionMember.characterDatabaseId = client.character.id;

                if (!server.database.InsertUnionMember(myUnionMember))
                {
                    _Logger.Error("union member could not be saved to database table nec_union_member");
                    return;
                }

                _Logger.Debug($"union member ID{myUnionMember.id} added to nec_union_member table");

                uint unionLeaderInstanceId     = server.instances.GetCharacterInstanceId(myUnion.leaderId);
                uint unionSubLeader1InstanceId = server.instances.GetCharacterInstanceId(myUnion.subLeader1Id);
                uint unionSubLeader2InstanceId = server.instances.GetCharacterInstanceId(myUnion.subLeader2Id);

                TimeSpan difference = client.union.created.ToUniversalTime() - DateTime.UnixEpoch;
                int      unionCreatedCalculation = (int)Math.Floor(difference.TotalSeconds);

                //Notify client if msg server found Union settings in database(memory) for client character Unique Persistant ID.
                IBuffer res = BufferProvider.Provide();
                res.WriteInt32(client.character.unionId);   //Union Instance ID
                res.WriteFixedString(myUnion.name, 0x31);   //size is 0x31
                res.WriteInt32(unionCreatedCalculation);
                res.WriteUInt32(unionLeaderInstanceId);     //Leader
                res.WriteInt32(-1);
                res.WriteUInt32(unionSubLeader1InstanceId); //subleader1
                res.WriteInt32(-1);
                res.WriteUInt32(unionSubLeader2InstanceId); //subleader2
                res.WriteInt32(-1);
                res.WriteByte((byte)myUnion.level);         //Union Level
                res.WriteUInt32(myUnion.currentExp);        //Union EXP Current
                res.WriteUInt32(myUnion.nextLevelExp);      //Union EXP next level Target
                res.WriteByte(myUnion
                              .memberLimitIncrease);        //Increase Union Member Limit above default 50 (See Union Bonuses
                res.WriteByte(0);
                res.WriteUInt32(client.character.instanceId);
                res.WriteInt16(myUnion.capeDesignId);                                                 //Mantle/Cape design
                res.WriteFixedString($"You are all members of {myUnion.name} now.  Welcome!", 0x196); //size is 0x196
                for (int i = 0; i < 8; i++)
                {
                    res.WriteInt32(i);
                }
                res.WriteByte(0);

                router.Send(client, (ushort)MsgPacketId.recv_union_notify_detail, res, ServerType.Msg);

                //Add all union members to your own instance of the union member list on your client
                foreach (UnionMember unionMemberList in server.database.SelectUnionMembersByUnionId(client.union.id))
                {
                    _Logger.Debug($"Loading union info for Member Id {unionMemberList.id}");
                    NecClient otherClient = server.clients.GetByCharacterId(unionMemberList.characterDatabaseId);
                    if (otherClient == null)
                    {
                        continue;
                    }

                    Character character = otherClient.character;
                    if (character == null)
                    {
                        continue;
                    }

                    Soul soul = otherClient.soul;
                    if (soul == null)
                    {
                        continue;
                    }


                    _Logger.Debug($"character is named {character.name}");
                    _Logger.Debug($"Soul is named {soul.name}");
                    TimeSpan differenceJoined       = unionMemberList.joined.ToUniversalTime() - DateTime.UnixEpoch;
                    int      unionJoinedCalculation = (int)Math.Floor(differenceJoined.TotalSeconds);
                    IBuffer  res3 = BufferProvider.Provide();
                    res3.WriteInt32(client.character.unionId);        //Union Id
                    res3.WriteUInt32(character.instanceId);
                    res3.WriteFixedString($"{soul.name}", 0x31);      //size is 0x31
                    res3.WriteFixedString($"{character.name}", 0x5B); //size is 0x5B
                    res3.WriteUInt32(character.classId);
                    res3.WriteByte(character.level);
                    res3.WriteInt32(character.mapId);                            // Location of your Union Member
                    res3.WriteInt32(0);                                          //Area of Map, somehow. or Channel;
                    res3.WriteFixedString($"Channel {character.channel}", 0x61); // Channel location
                    res3.WriteUInt32(unionMemberList
                                     .memberPriviledgeBitMask);                  //permissions bitmask  obxxxx1 = invite | obxxx1x = kick | obxx1xx = News | 0bxx1xxxxx = General Storage | 0bx1xxxxxx = Deluxe Storage
                    res3.WriteUInt32(unionMemberList.rank);                      //Rank  3 = beginner 2 = member, 1 = sub-leader 0 = leader
                    res3.WriteInt32(0);                                          //online status. 0 = online, 1 = away, 2 = offline
                    res3.WriteInt32(unionJoinedCalculation);                     //Date Joined in seconds since unix time
                    res3.WriteInt32(Util.GetRandomNumber(0, 3));
                    res3.WriteInt32(Util.GetRandomNumber(0, 3));
                    router.Send(client, (ushort)MsgPacketId.recv_union_notify_detail_member, res3, ServerType.Msg);
                }

                TimeSpan differenceInviteted     = DateTime.Now - DateTime.UnixEpoch;
                int      unionInvitedCalculation = (int)Math.Floor(differenceInviteted.TotalSeconds);

                //add you to all the member list of your union mates that were logged in when you joined.
                IBuffer res4 = BufferProvider.Provide();
                ;
                res4.WriteInt32(client.character.unionId);               //not sure what this is.  union_Notify ID?
                res4.WriteUInt32(client.character.instanceId);
                res4.WriteFixedString($"{client.soul.name}", 0x31);      //size is 0x31
                res4.WriteFixedString($"{client.character.name}", 0x5B); //size is 0x5B
                res4.WriteUInt32(client.character.classId);
                res4.WriteByte(client.character.level);
                res4.WriteInt32(client.character.mapId);                            // Location of your Union Member
                res4.WriteInt32(0);                                                 //Area of Map, somehow. or Channel;
                res4.WriteFixedString($"Channel {client.character.channel}", 0x61); // Channel location
                res4.WriteInt32(
                    0b11111111);                                                    //permissions bitmask  obxxxx1 = invite | obxxx1x = kick | obxx1xx = News | 0bxx1xxxxx = General Storage | 0bx1xxxxxx = Deluxe Storage
                res4.WriteInt32(3);                                                 //Rank  3 = beginner 2 = member, 1 = sub-leader 0 = leader
                res4.WriteInt32(0);                                                 //online status. 0 = online, 1 = away, 2 = offline
                res4.WriteInt32(unionInvitedCalculation);                           //Date Joined in seconds since unix time
                res4.WriteInt32(Util.GetRandomNumber(0, 3));
                res4.WriteInt32(Util.GetRandomNumber(0, 3));

                router.Send(client.union.unionMembers, (ushort)MsgPacketId.recv_union_notify_detail_member, res4,
                            ServerType.Msg, client);

                IBuffer res36 = BufferProvider.Provide();
                res36.WriteUInt32(client.character.instanceId);
                res36.WriteInt32(client.character.unionId);
                res36.WriteCString(myUnion.name);
                router.Send(client.map, (ushort)AreaPacketId.recv_chara_notify_union_data, res36, ServerType.Area);
            }
        }
コード例 #15
0
        public override void Handle(NecClient client, NecPacket packet)
        {
            string unionName = packet.Data.ReadCString(); //It's the Name of your new Union
            int    sys_msg   = 0;

            if (unionName.Length >= 16)
            {
                sys_msg = -1;
            }
            else if (client.Character.AdventureBagGold < 30000)
            {
                sys_msg = -2;
            }
            else if (client.Soul.Level < 3)
            {
                sys_msg = -3;
            }
            else if (client.Character.unionId != 0)
            {
                sys_msg = -4;
            }

            /*
             * else if (client.Soul.Level < 3) { sys_msg = -1711; }
             * else if (unionNameRegExpressionCheck(unionName)== fail) { sys_msg = -1701; }
             * else if (client.Character.unionId != 0) { sys_msg = -1702; }
             * else if (Server.Database.SelectUnionByName(unionName) != null) { sys_msg = -1704; }
             * else if (Server.Characters.GetAll().Count <= 5) { sys_msg = -1705; }
             * else if (client.Character.UnionLastLeave <= Date.Time.Now() - 24) { sys_msg = -1719; }
             */

            IBuffer res2 = BufferProvider.Provide();

            res2.WriteInt32(sys_msg);
            Router.Send(client, (ushort)AreaPacketId.recv_union_request_establish_r, res2, ServerType.Area);

            /*
             * UNION_CREATE	0	Union created
             * UNION_CREATE	-1	A union name must be 2 to 8 characters in length
             * UNION_CREATE	-2	Not enough gold
             * UNION_CREATE	-3	Insufficient Soul Rank
             * UNION_CREATE	-4	You already belong to a union
             * UNION_CREATE	-1711	Insufficient Soul Rank
             * UNION_CREATE	-1701	The union name you have entered includes unavailable characters
             * UNION_CREATE	-1702	You already belong to a union
             * UNION_CREATE	-1704	This union name is already in use
             * UNION_CREATE	-1705	Not enough people to create a union
             * UNION_CREATE	-1719	You may not create a Union for 24 hours after leaving your last Union.
             */

            if (sys_msg != 0)
            {
                return;
            }

            Union myFirstUnion = Server.Instances.CreateInstance <Union>();

            client.Character.unionId   = (int)myFirstUnion.InstanceId;
            myFirstUnion.Name          = unionName;
            myFirstUnion.UnionLeaderId = client.Character.Id;
            client.Union = myFirstUnion;

            if (!Server.Database.InsertUnion(myFirstUnion))
            {
                Logger.Error($"{unionName} could not be saved to database");
                Logger.Error($"{unionName} could not be saved to database");
                Logger.Error($"{unionName} could not be saved to database");
                return;
            }

            Logger.Debug($"{unionName} established with Id {myFirstUnion.Id} and instanceId {myFirstUnion.InstanceId}");

            UnionMember myFirstUnionMember = Server.Instances.CreateInstance <UnionMember>();

            myFirstUnionMember.UnionId                 = (int)myFirstUnion.Id;
            myFirstUnionMember.CharacterDatabaseId     = client.Character.Id;
            myFirstUnionMember.MemberPriviledgeBitMask = 0b11111111;
            myFirstUnionMember.Rank = 0;

            if (!Server.Database.InsertUnionMember(myFirstUnionMember))
            {
                Logger.Error($"union member could not be saved to database table nec_union_member");
                return;
            }

            Logger.Debug($"union member ID{myFirstUnionMember.Id} added to nec_union_member table");

            myFirstUnion.Join(client); //to-do,  add to unionMembers table.
            TimeSpan differenceCreated       = DateTime.Now - DateTime.UnixEpoch;
            int      unionCreatedCalculation = (int)Math.Floor(differenceCreated.TotalSeconds);


            IBuffer res3 = BufferProvider.Provide();

            res3.WriteInt32(client.Character.unionId);               //Union ID
            res3.WriteUInt32(client.Character.InstanceId);
            res3.WriteFixedString($"{client.Soul.Name}", 0x31);      //size is 0x31
            res3.WriteFixedString($"{client.Character.Name}", 0x5B); //size is 0x5B
            res3.WriteUInt32(client.Character.ClassId);
            res3.WriteByte(client.Character.Level);
            res3.WriteInt32(client.Character.MapId);                            // Location of your Union Member
            res3.WriteInt32(3);                                                 //??
            res3.WriteFixedString($"Channel {client.Character.Channel}", 0x61); // Channel location
            res3.WriteInt32(
                0b11111111);                                                    //permissions bitmask  obxxxx1 = invite | obxxx1x = kick | obxx1xx = News | 0bxx1xxxxx = General Storage | 0bx1xxxxxx = Deluxe Storage
            res3.WriteInt32(0);                                                 //Rank  3 = beginner 2 = member, 1 = sub-leader 0 = leader
            res3.WriteInt32(0);                                                 //online status. 0 = online, 1 = away, 2 = offline
            res3.WriteInt32(unionCreatedCalculation);                           //
            res3.WriteInt32(0);                                                 //
            res3.WriteInt32(0);                                                 //
            Router.Send(client, (ushort)MsgPacketId.recv_union_notify_detail_member, res3, ServerType.Msg);

            //Notify client if msg server found Union settings in database(memory) for client character Unique Persistant ID.
            IBuffer res = BufferProvider.Provide();

            res.WriteInt32(client.Character.unionId);     //Union Instance ID
            res.WriteFixedString(unionName, 0x31);        //size is 0x31
            res.WriteInt32(unionCreatedCalculation);
            res.WriteUInt32(client.Character.InstanceId); //Leader
            res.WriteInt32(-1);
            res.WriteInt32(0);                            //subleader1
            res.WriteInt32(-1);
            res.WriteInt32(0);                            //subleader2
            res.WriteInt32(-1);
            res.WriteByte(0);                             //Union Level
            res.WriteUInt32(myFirstUnion.CurrentExp);     //Union EXP Current
            res.WriteUInt32(myFirstUnion.NextLevelExp);   //Union EXP next level Target
            res.WriteByte(myFirstUnion
                          .MemberLimitIncrease);          //Increase Union Member Limit above default 50 (See Union Bonuses
            res.WriteByte(3);
            res.WriteUInt32(client.Character.InstanceId);
            res.WriteInt16(myFirstUnion.CapeDesignID);                                         //Mantle/Cape design
            res.WriteFixedString($"You are all members of {unionName} now.  Welcome!", 0x196); //size is 0x196
            for (int i = 0; i < 8; i++)
            {
                res.WriteInt32(i);
            }
            res.WriteByte(0);

            Router.Send(client, (ushort)MsgPacketId.recv_union_notify_detail, res, ServerType.Msg);

            IBuffer res36 = BufferProvider.Provide();

            res36.WriteUInt32(client.Character.InstanceId);
            res36.WriteInt32(client.Character.unionId);
            res36.WriteCString(unionName);
            Router.Send(client.Map, (ushort)AreaPacketId.recv_chara_notify_union_data, res36, ServerType.Area);
        }
コード例 #16
0
        public override void Handle(NecClient client, NecPacket packet)
        {
            UnionMember unionMember = Server.Database.SelectUnionMemberByCharacterId(client.Character.Id);

            if (unionMember == null)
            {
                Logger.Debug($"you don't appear to be in a union");
            }
            else
            {
                Logger.Debug($"union member ID{unionMember.Id} found. loading Union information");
                Union myUnion = Server.Database.SelectUnionById(unionMember.UnionId);

                if (myUnion == null)
                {
                    Logger.Error($"This is Strange.. Can't find a Union with id {unionMember.UnionId}");
                }
                else
                {
                    Logger.Debug($"union  ID{unionMember.UnionId} found. continuing loading of Union information");

                    client.Character.unionId = myUnion.Id;
                    client.Union             = myUnion;
                    client.Union.Join(client);

                    TimeSpan differenceCreated       = client.Union.Created.ToUniversalTime() - DateTime.UnixEpoch;
                    int      unionCreatedCalculation = (int)Math.Floor(differenceCreated.TotalSeconds);

                    //Notify client of each union member in above union, queried by charaname and InstanceId (for menu based interactions)
                    foreach (UnionMember unionMemberList in Server.Database.SelectUnionMembersByUnionId(client.Character
                                                                                                        .unionId))
                    {
                        Character character              = Server.Characters.GetByCharacterId(unionMemberList.CharacterDatabaseId);
                        Soul      soul                   = Server.Database.SelectSoulById(character.SoulId);
                        TimeSpan  differenceJoined       = unionMemberList.Joined.ToUniversalTime() - DateTime.UnixEpoch;
                        int       unionJoinedCalculation = (int)Math.Floor(differenceJoined.TotalSeconds);
                        IBuffer   res3                   = BufferProvider.Provide();
                        res3.WriteInt32(client.Character.unionId);        //Union Id
                        res3.WriteUInt32(character.InstanceId);
                        res3.WriteFixedString($"{soul.Name}", 0x31);      //size is 0x31
                        res3.WriteFixedString($"{character.Name}", 0x5B); //size is 0x5B
                        res3.WriteUInt32(character.ClassId);
                        res3.WriteByte(character.Level);
                        res3.WriteInt32(character.MapId);                            // Location of your Union Member
                        res3.WriteInt32(unionJoinedCalculation);                     //Area of Map, somehow. or Channel;
                        res3.WriteFixedString($"Channel {character.Channel}", 0x61); // Channel location
                        res3.WriteUInt32(unionMemberList
                                         .MemberPriviledgeBitMask);                  //permissions bitmask  obxxxx1 = invite | obxxx1x = kick | obxx1xx = News | 0bxx1xxxxx = General Storage | 0bx1xxxxxx = Deluxe Storage
                        res3.WriteUInt32(unionMemberList
                                         .Rank);                                     //Rank  3 = beginner 2 = member, 1 = sub-leader 0 = leader
                        res3.WriteInt32(0);                                          //online status. 0 = online, 1 = away, 2 = offline
                        res3.WriteInt32(unionJoinedCalculation);                     //Date Joined in seconds since unix time
                        res3.WriteInt32(Util.GetRandomNumber(0, 3));
                        res3.WriteInt32(Util.GetRandomNumber(0, 3));
                        Router.Send(client, (ushort)MsgPacketId.recv_union_notify_detail_member, res3, ServerType.Msg);
                    }


                    uint UnionLeaderInstanceId     = Server.Characters.GetByCharacterId(myUnion.UnionLeaderId).InstanceId;
                    uint UnionSubLeader1InstanceId = 0;
                    if (myUnion.UnionSubLeader1Id != 0)
                    {
                        UnionSubLeader1InstanceId =
                            Server.Characters.GetByCharacterId(myUnion.UnionSubLeader1Id).InstanceId;
                    }

                    uint UnionSubLeader2InstanceId = 0;
                    if (myUnion.UnionSubLeader2Id != 0)
                    {
                        UnionSubLeader2InstanceId =
                            Server.Characters.GetByCharacterId(myUnion.UnionSubLeader2Id).InstanceId;
                    }


                    //Notify client if msg server found Union settings in database(memory) for client character Unique Persistant ID.
                    IBuffer res = BufferProvider.Provide();
                    res.WriteInt32(unionMember.UnionId);        //Union Instance ID //form the ToDo Logic above
                    res.WriteFixedString(myUnion.Name, 0x31);   //size is 0x31
                    res.WriteInt32(unionCreatedCalculation);    //Creation Date in seconds since unix 0 time (Jan. 1, 1970)
                    res.WriteUInt32(UnionLeaderInstanceId);     //Leader
                    res.WriteInt32(0);
                    res.WriteUInt32(UnionSubLeader1InstanceId); //subleader1
                    res.WriteInt32(0);
                    res.WriteUInt32(UnionSubLeader2InstanceId); //subleader2
                    res.WriteInt32(0);
                    res.WriteByte((byte)myUnion.Level);         //Union Level
                    res.WriteUInt32(myUnion.CurrentExp);        //Union EXP Current
                    res.WriteUInt32(myUnion.NextLevelExp);      //Union EXP next level Target
                    res.WriteByte(myUnion
                                  .MemberLimitIncrease);        //Increase Union Member Limit above default 50 (See Union Bonuses
                    res.WriteByte(myUnion.MemberLimitIncrease);
                    res.WriteInt32(999999999);                  //Creation Date?
                    res.WriteInt16(myUnion.CapeDesignID);       //Mantle/Cape
                    res.WriteFixedString($"You are all members of {myUnion.Name} now.  Welcome!",
                                         0x196);                //size is 0x196
                    for (int i = 0; i < 8; i++)
                    {
                        res.WriteInt32(-1);
                    }
                    res.WriteByte(255);
                    Router.Send(client, (ushort)MsgPacketId.recv_union_notify_detail, res, ServerType.Msg);
                }
            }


            //Acknowledge send.  'Hey send,  i'm finished doing my stuff.  go do the next stuff'
            IBuffer res2 = BufferProvider.Provide();

            res2.WriteInt32(client.Character.unionId); //probably error check. 0 for success
            Router.Send(client, (ushort)MsgPacketId.recv_union_request_detail_r, res2, ServerType.Msg);
        }