/// <summary>
        /// Removes an entity.
        /// </summary>
        /// <param name="entity">The entity to remove.</param>
        public void RemoveEntity(Entity entity)
        {
            List <Entity> entityList = GetEntitiesByType(entity.GetEntityType());

            if (entityList == null)
            {
                entityList = new List <Entity>();
            }
            if (entities.ContainsKey(entity.GetEntityType()))
            {
                entities.Remove(entity.GetEntityType());
            }
            entityList.Remove(entity);
            entities.Add(entity.GetEntityType(), entityList);
        }
Example #2
0
        public MethodResult CanCreateCountryCompany(Entity entity, Country country, Citizen loggedCitizen)
        {
            if (country == null)
            {
                return(new MethodResult("Country is not defined!"));
            }

            var policy = (LawAllowHolderEnum)countryRepository.GetCountryPolicySetting(country.ID, pol => pol.CountryCompanyBuildLawAllowHolder);

            if (entity.GetEntityType() != EntityTypeEnum.Citizen)
            {
                return(new MethodResult("Only citizens can create national companies!"));
            }

            if (country.PresidentID == entity.EntityID && policy == LawAllowHolderEnum.Congress)
            {
                return(new MethodResult("Only congress can create companies in your country!"));
            }
            if (congressVotingService.IsCongressman(loggedCitizen, country) && policy == LawAllowHolderEnum.President)
            {
                return(new MethodResult("Only president can create companies in your country!"));
            }

            var neededGold   = ConfigurationHelper.Configuration.CompanyCountryFee;
            var treasureGold = walletService.GetWalletMoney(country.Entity.WalletID, GameHelper.Gold.ID);

            if (treasureGold.Amount < neededGold)
            {
                return(new MethodResult($"Not enough gold to construct company. You need {neededGold} gold and your country only have {treasureGold.Amount} gold"));
            }

            return(MethodResult.Success);
        }
        public static decimal GetCompanyCost(this CountryPolicy policy, Entity entity)
        {
            switch (entity.GetEntityType())
            {
            case EntityTypeEnum.Citizen:
            {
                return(policy.CitizenCompanyCost);
            }

            case EntityTypeEnum.Organisation:
            {
                return(policy.OrganisationCompanyCost);
            }

            case EntityTypeEnum.Country:
            {
                return(0m);
            }

            default:
            {
                throw new NotImplementedException();
            }
            }
        }
        public static decimal GetCompanyFee(this ConfigurationTable config, Entity entity)
        {
            switch (entity.GetEntityType())
            {
            case EntityTypeEnum.Citizen:
            {
                return(config.CompanyCitizenFee);
            }

            case EntityTypeEnum.Organisation:
            {
                return(config.CompanyOrganisationFee);
            }

            case EntityTypeEnum.Country:
            {
                return(config.CompanyCountryFee);
            }

            default:
            {
                throw new NotImplementedException();
            }
            }
        }
    /// Iterates through all entities and performs the action once for each entity
    public static void AccessAllEntities(Action <Entity> act, EntityType?onlyType = null)
    {
        ChunkCoords check      = ChunkCoords.Zero;
        bool        limitCheck = onlyType != null;

        //Check every direction
        for (int dir = 0; dir < instance.grid.Count; dir++)
        {
            check.quadrant = (Quadrant)dir;
            //Check every column
            for (int x = 0; x < Quad(check).Count; x++)
            {
                check.x = x;
                //Check every row
                for (int y = 0; y < Column(check).Count; y++)
                {
                    check.y = y;
                    //Check every entity in chunk
                    for (int i = Chunk(check).Count; i >= 0; i--)
                    {
                        Entity e = Chunk(check)[i];
                        //only access entities with the given type (any if no type is given)
                        if ((limitCheck && e.GetEntityType() == (EntityType)onlyType) || !limitCheck)
                        {
                            act(e);
                        }
                    }
                }
            }
        }
    }
Example #6
0
    public override bool ValidateSelection(Entity entity)
    {
        if (entity.GetEntityType() != "Tile")
            return false;

        Tile tile = entity as Tile;

        if (tile.Occupied)
            return false;

        if (!tile.Walkable)
            return false;

        Tile playerTile = character.currentTile;

        int xDif = Mathf.Abs(playerTile.X - tile.X);
        if (xDif > moveRange)
            return false;

        int yDif = Mathf.Abs(playerTile.Y - tile.Y);
        if (yDif > moveRange)
            return false;

        if ((xDif + yDif) > moveRange)
            return false;

        return character.GetActionPoints() > 0;
    }
Example #7
0
 protected void HandleYMovement(Directions aDir, Entity targetEntity, Entity potentialPushToEntity)
 {
     if (targetEntity.GetIsSolid() == false)
     {
         SetLocationY(aDir);
     }
     else
     {
         if (targetEntity.GetEntityType() == EntityTypes.MovableBlock)
         {
             if (potentialPushToEntity.GetIsSolid())
             {
                 return;
             }
             else
             {
                 targetEntity.Move(aDir);
                 SetLocationY(aDir);
             }
         }
         else
         {
             return;
         }
     }
 }
Example #8
0
        private bool canChangeIntoOrganisation(Entity currentEntity, Organisation organisation, Citizen loggedCitizen)
        {
            if (currentEntity.GetEntityType() != EntityTypeEnum.Citizen && (currentEntity.GetEntityType() != EntityTypeEnum.Company))
            {
                return(false);
            }

            List <int> managersIDs = new List <int>()
            {
                organisation.OwnerID.Value
            };

            managersIDs.AddRange(organisation.Managers.Select(m => m.ID).ToList());

            return(managersIDs.Contains(loggedCitizen.ID));
        }
Example #9
0
        public Newspaper CreateNewspaper(Entity owner, string newspaperName, int newspaperCountryID, Citizen loggedCitizen)
        {
            using (var transaction = transactionScopeProvider.CreateTransactionScope())
            {
                Entity entity = entityService.CreateEntity(newspaperName, EntityTypeEnum.Newspaper);
                entity.Equipment.ItemCapacity = 1000;
                var newspaper = new Newspaper()
                {
                    CountryID = newspaperCountryID,
                    OwnerID   = owner.EntityID,
                    Entity    = entity
                };

                newspaperRepository.Add(newspaper);
                newspaperRepository.SaveChanges();

                if (owner.GetEntityType() != EntityTypeEnum.Party)
                {
                    transactionService.PayForNewspaperCreation(newspaper, owner);
                }
                else
                {
                    transactionService.PayForNewspaperCreation(newspaper, loggedCitizen.Entity);
                }

                transaction.Complete();

                return(newspaper);
            }
        }
Example #10
0
        public static Region GetCurrentRegion(this Entity entity)
        {
            switch (entity.GetEntityType())
            {
            case EntityTypeEnum.Citizen:
            {
                return(entity.Citizen.Region);
            }

            case EntityTypeEnum.Company:
            {
                return(entity.Company.Region);
            }

            case EntityTypeEnum.Hotel:
            {
                return(entity.Hotel.Region);
            }

            default:
            {
                return(null);
            }
            }
        }
Example #11
0
        private Dictionary <long, PredefinedRelationType> GetPredefinedRelationTypes(Entity entity)
        {
            Type entityType = Entity.GetEntityType(entity);

            if (!predefinedRelationTypes.ContainsKey(entityType))
            {
                predefinedRelationTypes[entityType] = new Dictionary <long, PredefinedRelationType> ();

                // Find all the properties that are marked as predefined relations.
                foreach (PropertyInfo property in entityType.GetProperties())
                {
                    object[] attributes = property.GetCustomAttributes(typeof(PredefinedRelationAttribute), false);
                    if (attributes.Any())
                    {
                        // The property represents predefined relation, take just the first attribute.
                        PredefinedRelationAttribute attribute = (PredefinedRelationAttribute)attributes[0];
                        long relationTypeId = (long)attribute.RelationTypeValue;

                        // We know that the attribute is applied on ICollection<TEntity>.
                        Type objectiveEntityType = property.PropertyType.GetGenericArguments()[0];

                        predefinedRelationTypes[entityType][relationTypeId] = new PredefinedRelationType(property)
                        {
                            Id   = relationTypeId,
                            Name = attribute.RelationTypeValue.ToString(),
                            SubjectiveEntityType = entityType,
                            ObjectiveEntityType  = objectiveEntityType
                        };
                    }
                }
            }

            return(predefinedRelationTypes[entityType]);
        }
Example #12
0
        public bool CanChangeInto(Entity currentEntity, Entity desiredEntity, Citizen loggedCitizen)
        {
            switch (desiredEntity.GetEntityType())
            {
            case EntityTypeEnum.Citizen:
                return(canChangeIntoCitizen(currentEntity, desiredEntity.Citizen, loggedCitizen));

            case EntityTypeEnum.Company:
                return(canChangeIntoCompany(currentEntity, desiredEntity.Company, loggedCitizen));

            case EntityTypeEnum.Party:
                return(canChangeIntoParty(currentEntity, desiredEntity.Party, loggedCitizen));

            case EntityTypeEnum.Organisation:
                return(canChangeIntoOrganisation(currentEntity, desiredEntity.Organisation, loggedCitizen));

            case EntityTypeEnum.Country:
                return(canChangeIntoCountry(currentEntity, desiredEntity.Country, loggedCitizen));

            case EntityTypeEnum.Newspaper:
                return(canChangeIntoNewspaper(currentEntity, desiredEntity.Newspaper, loggedCitizen));

            case EntityTypeEnum.Hotel:
                return(canChangeIntoHotel(currentEntity, desiredEntity.Hotel, loggedCitizen));

            default:
                throw new NotImplementedException();
            }
        }
Example #13
0
        /// <summary>
        /// Adds an entity to the manager system.
        /// </summary>
        /// <param name="entity">The entity instance.</param>
        public void AddEntity(Entity entity)
        {
            List <Entity> entityList = GetEntitiesByType(entity.GetEntityType());

            if (entityList == null)
            {
                entityList = new List <Entity>();
            }
            if (entities.ContainsKey(entity.GetEntityType()))
            {
                entities.Remove(entity.GetEntityType());
            }
            entityList.Add(entity);
            Console.WriteLine("Adding entity type=" + entity.GetType() + ", entity=" + entity);
            entities.Add(entity.GetEntityType(), entityList);
            Console.WriteLine(entities.Count);
        }
 public void recalc()
 {
     if (ent == null)
     {
         label1.Text       = "Entity: /WORLD/";
         textBox2.Text     = "/WORLD/";
         textBox2.ReadOnly = true;
     }
     else
     {
         label1.Text       = "Entity: " + ent.GetEntityType();
         textBox2.Text     = ent.GetEntityType();
         textBox2.ReadOnly = false;
     }
     resetListBoxContents();
     textBox1.ReadOnly = true;
 }
Example #15
0
 public SmallEntityAvatarViewModel(Entity entity)
     : this(entity.EntityID, entity.Name, entity.ImgUrl)
 {
     if (entity.GetEntityType() == EntityTypeEnum.Country)
     {
         Avatar = Images.GetCountryFlag(entity.EntityID).VM;
     }
 }
 private void ResetEntityRagdoll(Entity entity)
 {
     if (entity.GetEntityType() == EntityType.Ped)
     {
         var p = new Ped(entity.Handle);
         p.Euphoria.StopAllBehaviours.Start(0);
         p.Task.ClearAll();
     }
 }
Example #17
0
        public bool IsAllowedItemFor(Entity entity, ProductTypeEnum productType)
        {
            var allowed = GetAllowedProductsForEntity(entity.GetEntityType());

            if (allowed.Contains(productType) == false)
            {
                return(false);
            }
            if (entity.GetEntityType() == EntityTypeEnum.Company)
            {
                allowed = GetAllowedProductsForCompany(entity.Company);
                if (allowed.Contains(productType) == false)
                {
                    return(false);
                }
            }
            return(true);
        }
Example #18
0
    public virtual bool IsEnemy(Entity entity)
    {
        if (this.GetEntityType() != EntityType.ROLE || entity.GetEntityType() != EntityType.ROLE)
        {
            return(false);
        }

        return(this.GetPlayerId() != entity.GetPlayerId());
    }
Example #19
0
        public MethodResult CanStartRessistanceBattle(Entity entity, Region region)
        {
            if (entity.GetEntityType() != EntityTypeEnum.Citizen)
            {
                return(new MethodResult("Only citizen can start battle!"));
            }

            return(CanStartRessistanceBattle(entity.Citizen, region));
        }
Example #20
0
        private bool canChangeIntoCompany(Entity currentEntity, Company company, Citizen loggedCitizen)
        {
            var companyService = DependencyResolver.Current.GetService <ICompanyService>();

            if (currentEntity.GetEntityType() != EntityTypeEnum.Citizen && currentEntity.GetEntityType() != EntityTypeEnum.Organisation)
            {
                return(false);
            }

            var rights = companyService.GetCompanyRights(company, currentEntity, loggedCitizen);

            if (rights.CanSwitch == false)
            {
                return(false);
            }

            return(true);
        }
Example #21
0
                public void WriteToFile(BinaryWriter writer)
                {
                    writer.Write(header.ToCharArray());
                    writer.Write(unk02);
                    writer.Write(unk03);
                    writer.Write(unk04);
                    writer.Write(unk05);
                    writer.Write(unk06);
                    writer.Write(unk07);
                    writer.Write(unk08);
                    writer.Write(unk09);
                    writer.Write(numEntities);

                    foreach (var Entity in entities)
                    {
                        writer.Write(126); //Header for types is 126.

                        long sizePosition = writer.BaseStream.Position;
                        writer.Write(-1);
                        writer.Write((int)Entity.GetEntityType());

                        using (MemoryStream stream = new MemoryStream())
                        {
                            // Write Entity to the Stream
                            CutsceneEntityFactory.WriteAnimEntityToFile(stream, Entity);
                            writer.Write(stream.ToArray());

                            // Update Size.
                            long currentPosition = writer.BaseStream.Position;
                            writer.BaseStream.Seek(sizePosition, SeekOrigin.Begin);
                            writer.Write((uint)stream.Length + 12);
                            writer.BaseStream.Seek(currentPosition, SeekOrigin.Begin);
                        }
                    }

                    foreach (var Entity in entities)
                    {
                        using (MemoryStream EntityStream = new MemoryStream())
                        {
                            bool isBigEndian = false;
                            Entity.AnimEntityData.WriteToFile(EntityStream, isBigEndian);

                            EntityStream.Seek(4, SeekOrigin.Begin);
                            EntityStream.Write((uint)EntityStream.Length, isBigEndian);
                            EntityStream.Seek(0, SeekOrigin.End);

                            writer.Write(EntityStream.ToArray());
                        }
                    }

                    writer.Write(unk10);
                    writer.Write(unk11);
                    writer.Write(unk12);
                    writer.Write(unk13);
                    writer.Write(unk14);
                }
Example #22
0
        private Dictionary <long, RelationType> GetGenericRelationTypes(Entity entity)
        {
            Type entityType = Entity.GetEntityType(entity);

            if (genericRelationTypes.ContainsKey(entityType))
            {
                return(genericRelationTypes[entityType]);
            }
            return(new Dictionary <long, RelationType> ());
        }
Example #23
0
 public bool CanUseFuel(Entity entity)
 {
     switch (entity.GetEntityType())
     {
     case EntityTypeEnum.Citizen:
     case EntityTypeEnum.Country:
     case EntityTypeEnum.Newspaper:
     case EntityTypeEnum.Party:
         return(false);
     }
     return(true);
 }
Example #24
0
 public void Add(Entity en, bool correction, Player forPlayer = null)
 {
     lock (mMovements)
     {
         var id = forPlayer?.Id ?? Guid.Empty;
         if (!mMovements.ContainsKey(id))
         {
             mMovements.Add(id, new List <EntityMovePacket>());
         }
         mMovements[id].Add(new EntityMovePacket(en.Id, en.GetEntityType(), en.MapId, (byte)en.X, (byte)en.Y, (byte)en.Dir, correction));
     }
 }
Example #25
0
                public void WriteToFile(BinaryWriter Writer)
                {
                    Writer.Write(1000); // Magic
                    long SPDSizePosition = Writer.BaseStream.Position;

                    Writer.Write(Size);
                    Writer.Write(0x21445053);
                    Writer.Write(Unk01);
                    Writer.Write(Unk02);
                    Writer.Write(EntityDefinitions.Length);

                    foreach (var Entity in EntityDefinitions)
                    {
                        Writer.Write(126); //Header for types is 126.

                        long sizePosition = Writer.BaseStream.Position;
                        Writer.Write(-1);
                        Writer.Write((int)Entity.GetEntityType());

                        using (MemoryStream EntityStream = new MemoryStream())
                        {
                            CutsceneEntityFactory.WriteAnimEntityToFile(EntityStream, Entity);
                            Writer.Write(EntityStream.ToArray());

                            long currentPosition = Writer.BaseStream.Position;
                            Writer.BaseStream.Seek(sizePosition, SeekOrigin.Begin);
                            Writer.Write((uint)EntityStream.Length + 12);
                            Writer.BaseStream.Seek(currentPosition, SeekOrigin.Begin);
                        }
                    }

                    foreach (var Entity in EntityDefinitions)
                    {
                        using (MemoryStream EntityStream = new MemoryStream())
                        {
                            bool isBigEndian = false;
                            Entity.AnimEntityData.WriteToFile(EntityStream, isBigEndian);

                            EntityStream.Seek(4, SeekOrigin.Begin);
                            EntityStream.Write((uint)EntityStream.Length, isBigEndian);
                            EntityStream.Seek(0, SeekOrigin.End);

                            Writer.Write(EntityStream.ToArray());
                        }
                    }

                    Writer.Seek((int)SPDSizePosition, SeekOrigin.Begin);
                    uint SPDSize = (uint)(Writer.BaseStream.Length - SPDSizePosition) + 4;

                    Writer.Write(SPDSize);
                    Writer.Seek(0, SeekOrigin.End);
                }
Example #26
0
        public MethodResult CanCreateNewspaper(Entity entity)
        {
            var result = MethodResult.Success;

            switch (entity.GetEntityType())
            {
            //It's better to have list of who is not allowed to create newspaper insteaed of who is not allowed ,
            //because when i do not allowed list then every new entity type will be allowed to make newspaper as it want to.
            case EntityTypeEnum.Citizen:
            case EntityTypeEnum.Company:
            case EntityTypeEnum.Country:
            case EntityTypeEnum.Organisation:
            case EntityTypeEnum.Party:
                break;

            default:
                result.AddError("You cannot create newspaper as {0}", entity.GetEntityType().ToHumanReadable());
                break;
            }

            return(result);
        }
Example #27
0
        private bool canChangeIntoCountry(Entity currentEntity, Country country, Citizen loggedCitizen)
        {
            if (currentEntity.GetEntityType() != EntityTypeEnum.Citizen)
            {
                return(false);
            }

            if (country.PresidentID != loggedCitizen.ID)
            {
                return(false);
            }

            return(true);
        }
Example #28
0
        private bool canChangeIntoCitizen(Entity currentEntity, Citizen citizen, Citizen loggedCitizen)
        {
            if (currentEntity.GetEntityType() == EntityTypeEnum.Citizen)
            {
                return(false);
            }

            if (citizen.ID != loggedCitizen.ID)
            {
                return(false);
            }

            return(citizen.ID == loggedCitizen.ID);
        }
Example #29
0
    public List <Role> GetFriendList(Role role)
    {
        List <Role> friend_list = new List <Role>();

        foreach (KeyValuePair <int, Entity> pair in this.entity_map)
        {
            Entity entity = pair.Value;
            if (entity.GetEntityType() == EntityType.ROLE && role.IsFriend((Role)entity))
            {
                friend_list.Add((Role)entity);
            }
        }
        return(friend_list);
    }
Example #30
0
        public bool WillGiftUseFuel(Entity source, Entity destination)
        {
            var entityTypesUsingFuel = new EntityTypeEnum[]
            {
                EntityTypeEnum.Newspaper,
                EntityTypeEnum.Company
            };

            if (source.Is(EntityTypeEnum.Company) && entityTypesUsingFuel.Contains(destination.GetEntityType()))
            {
                return(true);
            }

            return(false);
        }
Example #31
0
        private bool canChangeIntoParty(Entity currentEntity, Party party, Citizen loggedCitizen)
        {
            if (currentEntity.GetEntityType() != EntityTypeEnum.Citizen)
            {
                return(false);
            }

            var managersIDs = party.PartyMembers
                              .Where(pm => pm.PartyRoleID >= (int)PartyRoleEnum.Manager)
                              .Select(pm => pm.CitizenID)
                              .ToList();


            return(managersIDs.Contains(loggedCitizen.ID));
        }
Example #32
0
    public override void OnSelctionAction(Entity entity)
    {
        if (entity.GetEntityType() != "SlideCharacter") return;
        var slide = entity as SlideCharacter;
        if (slide.Team != team) return;

        if (selectedCharacter)
        {
            ConflictController.Instance.RemovePulseMaterial(selectedCharacter.GetComponent<Renderer>());
        }
        selectedCharacter = entity as SlideCharacter;

        AbilityButtonControl.Instance.ChangeSelectedCharacter(slide);
        GridController.DisplayMoveRange(selectedCharacter);

        ConflictController.Instance.AddPulseMaterial(selectedCharacter.Avatar.GetComponent<Renderer>());
    }
Example #33
0
    public bool OnEntitySelection(Entity entity)
    {
        if (entity.GetEntityType() == "Tile")
            currentAction = allowedActions["Move"];

        if (currentAction.ValidateSelection(entity) == false)
        {
            return false;
        }
        currentAction.PreformAction(entity);

        currentAction = fallbackAction;
        return true;
    }
Example #34
0
    public override bool ValidateSelection(Entity entity)
    {
        if (character.GetActionPoints() <= 0) return false;
        switch (targetType)
        {
            case TargetType.Character:
                if (entity.GetEntityType() != "SlideCharacter")
                {
                    return false;
                }

                SlideCharacter ch = entity as SlideCharacter;

                switch (targetFilter)
                {
                    case TargetFilter.Enemy:
                        if (ch.Team == character.Team) return false;
                        break;
                    case TargetFilter.Freindly:
                        if (ch.Team != character.Team) return false;
                        break;
                    default:

                        break;
                }

                break;
            case TargetType.Tile:
                if (entity.GetEntityType() != "Tile") return false;
                break;
            case TargetType.Either:
                if (entity.GetEntityType() != "Tile" && entity.GetEntityType() != "SlideCharacter") return false;
                break;
            case TargetType.Self:
                if (entity != character) return false;
                break;
            default:
                return false;
        }

        var tile = entity.getCurrentTile();
        int xDif = Mathf.Abs(tile.X - character.currentTile.X);
        if (xDif > range)
        {
            return false;
        }
        int yDif = Mathf.Abs(tile.Y - character.currentTile.Y);
        if (yDif > range)
        {
            return false;
        }
        int total = xDif + yDif;
        if (targetRange == TargetRange.Melee)
        {
            if (total > 2)
            {
                return false;
            }
        }
        else
        {
            if (total > (range * 2))
            {
                return false;
            }
        }
        return true;
    }