public static void BuyCompany(GameContext gameContext, int companyId, int buyerInvestorId, long offer)
        {
            // can afford acquisition
            var inv = Investments.GetInvestorById(gameContext, buyerInvestorId);

            if (!IsEnoughResources(inv, offer))
            {
                return;
            }

            var target = Get(gameContext, companyId);

            var shareholders = GetShareholders(target);

            int[] array = new int[shareholders.Keys.Count];
            shareholders.Keys.CopyTo(array, 0);

            foreach (var shareholderId in array)
            {
                BuyShares(gameContext, companyId, buyerInvestorId, shareholderId, shareholders[shareholderId].amount, offer, true);
            }

            RemoveAllPartnerships(target, gameContext);

            RemoveAcquisitionOffer(gameContext, companyId, buyerInvestorId);

            target.isIndependentCompany = false;

            NotifyAboutAcquisition(gameContext, buyerInvestorId, companyId, offer);
        }
        public static GameEntity GetParentCompany(GameContext context, GameEntity company)
        {
            if (company.isIndependentCompany)
            {
                return(null);
            }


            var        shares       = 0;
            var        shareholders = company.shareholders.Shareholders;
            GameEntity parent       = null;

            foreach (var shareholder in shareholders)
            {
                var id    = shareholder.Key;
                var block = shareholder.Value.amount;

                var investor = Investments.GetInvestor(context, id);

                if (investor.hasCompany)
                {
                    // is managing company
                    if (block > shares)
                    {
                        parent = investor;
                    }
                }
            }

            return(parent);
        }
示例#3
0
        public static void AddShares(GameContext gameContext, GameEntity company, int investorId, int amountOfShares)
        {
            var shareholders = company.shareholders.Shareholders;
            var shareholder  = Investments.GetInvestorById(gameContext, investorId).shareholder;

            if (IsInvestsInCompany(company, investorId))
            {
                var prev = shareholders[investorId];

                shareholders[investorId] = new BlockOfShares
                {
                    amount             = prev.amount + amountOfShares,
                    InvestorType       = prev.InvestorType,
                    shareholderLoyalty = prev.shareholderLoyalty,
                };
            }
            else
            {
                // new investor
                shareholders[investorId] = new BlockOfShares
                {
                    amount             = amountOfShares,
                    InvestorType       = shareholder.InvestorType,
                    shareholderLoyalty = 100,
                };
            }

            ReplaceShareholders(company, shareholders);
        }
示例#4
0
        public static GameEntity[] GetPotentialInvestors(GameContext gameContext, int companyId)
        {
            var investors = gameContext.GetEntities(GameMatcher.Shareholder);

            var c = Get(gameContext, companyId);

            return(Array.FindAll(investors, s => Investments.IsInvestorSuitable(s, c)));
        }
示例#5
0
        public static GameEntity GenerateInvestmentFund(GameContext context, string name, long money)
        {
            var c = CreateCompany(context, name, CompanyType.FinancialGroup);

            Investments.BecomeInvestor(context, c, money);

            return(c);
        }
示例#6
0
        public static GameEntity GenerateCompanyGroup(GameContext context, string name)
        {
            var c = CreateCompany(context, name, CompanyType.Group);

            c.isManagingCompany = true;

            Investments.BecomeInvestor(context, c, 0);

            return(c);
        }
        public static bool IsDaughterOf(GameEntity parent, GameEntity daughter)
        {
            if (!parent.hasShareholder)
            {
                Companies.Log(daughter, $"FALSELY CALLED IS_DAUGHTER_OF on companies: possible parent={parent.company.Name}, possible daughter={daughter.company.Name}");
                return(false);
            }

            return(Investments.IsInvestsInCompany(parent, daughter)); // IsInvestsInCompany(daughter, parent.shareholder.Id);
        }
示例#8
0
        public static long GetFounderExitDesire(GameEntity startup, int shareholderId, GameContext gameContext)
        {
            var founder = Investments.GetInvestor(gameContext, shareholderId);

            var ambition = Humans.GetFounderAmbition(founder.humanSkills.Traits, Humans.GetRating(founder));

            if (ambition == Ambition.EarnMoney)
            {
                return(C.COMPANY_DESIRE_TO_SELL_YES);
            }

            return(C.COMPANY_DESIRE_TO_SELL_NO);
        }
示例#9
0
        public static long GetFounderExitDesire(GameEntity startup, int shareholderId, GameContext gameContext)
        {
            var founder = Investments.GetInvestorById(gameContext, shareholderId);

            var ambitions = founder.humanSkills.Traits[TraitType.Ambitions];

            var ambition = Humans.GetFounderAmbition(ambitions);

            if (ambition == Ambition.EarnMoney)
            {
                return(Balance.COMPANY_DESIRE_TO_SELL_YES);
            }

            return(Balance.COMPANY_DESIRE_TO_SELL_NO);
        }
        internal static GameEntity PreparePlayerCompany(GameEntity niche, long startCapital, string text, GameContext gameContext)
        {
            var company = Companies.GenerateCompanyGroup(gameContext, text);

            company.ReplaceCorporateCulture(Companies.GetPlayerCorporateCulture());


            Companies.SetResources(company, startCapital, "start capital");

            Companies.PlayAs(company, gameContext);

            Investments.SetGrowthStyle(company, CompanyGrowthStyle.None);
            Investments.SetVotingStyle(company, VotingStyle.None);
            Investments.SetExitStrategy(company, InvestorInterest.None);

            Companies.AutoFillShareholders(gameContext, company, true);

            return(company);
        }
示例#11
0
        public static List <CompanyHolding> GetPersonalHoldings(GameContext context, int shareholderId, bool recursively)
        {
            List <CompanyHolding> companyHoldings = new List <CompanyHolding>();

            var investments = Investments.GetInvestmentsOf(context, shareholderId);

            foreach (var investment in investments)
            {
                var holding = new CompanyHolding
                {
                    companyId = investment.company.Id,
                    control   = GetShareSize(context, investment.company.Id, shareholderId),
                    holdings  = recursively ? GetCompanyHoldings(context, investment.company.Id, recursively) : new List <CompanyHolding>()
                };

                companyHoldings.Add(holding);
            }

            return(companyHoldings);
        }
示例#12
0
        public static void AutoFillShareholders(GameContext gameContext, GameEntity c, bool founderOnly)
        {
            var founder     = c.cEO.HumanId;
            var shareholder = Humans.Get(gameContext, founder);

            Investments.BecomeInvestor(gameContext, shareholder, 100000);

            AddShares(c, shareholder, 500);

            if (founderOnly)
            {
                return;
            }

            for (var i = 0; i < UnityEngine.Random.Range(1, 5); i++)
            {
                var investor = Investments.GetRandomInvestmentFund(gameContext);

                AddShares(c, investor, 100);
            }
        }
示例#13
0
        public static void DecreaseShares(GameContext gameContext, GameEntity company, int investorId, int amountOfShares)
        {
            var shareholders = company.shareholders.Shareholders;
            var shareholder  = Investments.GetInvestorById(gameContext, investorId).shareholder;

            var prev = shareholders[investorId];

            if (amountOfShares >= prev.amount)
            {
                // needs to be deleted
                RemoveShareholder(company, investorId);
                return;
            }

            shareholders[investorId] = new BlockOfShares
            {
                amount             = prev.amount - amountOfShares,
                InvestorType       = prev.InvestorType,
                shareholderLoyalty = prev.shareholderLoyalty
            };

            ReplaceShareholders(company, shareholders);
        }
示例#14
0
        public static void JoinCorporation(GameContext gameContext, int companyId, int buyerInvestorId)
        {
            var target      = Get(gameContext, companyId);
            var corporation = Investments.GetCompanyByInvestorId(gameContext, buyerInvestorId);

            var shareholders = GetShareholders(target);

            int[] array = new int[shareholders.Keys.Count];


            var corporationCost = Economy.GetCompanyCost(gameContext, corporation);
            var targetCost      = Economy.GetCompanyCost(gameContext, target);

            var corporationShares = Companies.GetTotalShares(gameContext, companyId);
            var emitedShares      = corporationShares * targetCost / corporationCost;

            // give shares in corporation to shareholders of integratable company
            foreach (var shareholderId in array)
            {
                var percentOfSharesInPreviousCompany = GetShareSize(gameContext, companyId, shareholderId);

                var newShare = emitedShares * percentOfSharesInPreviousCompany / 100;

                AddShares(gameContext, corporation, shareholderId, (int)newShare);
                Debug.Log($"investor {GetInvestorName(gameContext, shareholderId)} will get {(int)newShare} shares of corporation {corporation.company.Name}");
            }


            foreach (var shareholderId in array)
            {
                RemoveShareholder(target, shareholderId);
            }
            AddShareholder(gameContext, companyId, buyerInvestorId, 100);
            target.isIndependentCompany = false;

            NotifyAboutCorporateAcquisition(gameContext, buyerInvestorId, companyId);
        }
        public static void ApplyGroupInvestmentsToProfitBonus(GameEntity c, GameContext context, Bonus <long> bonus)
        {
            if (!Companies.IsGroup(c))
            {
                return;
            }

            var holdings = Investments.GetHoldings(c, context, true);

            bool isOnlyHolding = holdings.Count == 1;

            foreach (var h in holdings)
            {
                var b = GetProfit(context, h.company, true);

                if (isOnlyHolding)
                {
                    // render full description
                    foreach (var d in b.bonusDescriptions)
                    {
                        if (d.HideIfZero)
                        {
                            bonus.AppendAndHideIfZero(d.Name, d.Value);
                        }
                        else
                        {
                            bonus.Append(d.Name, d.Value);
                        }
                    }
                }
                else
                {
                    // general info is enough
                    bonus.Append(h.company.company.Name, b.Sum());
                }
            }
        }
示例#16
0
        public static GameEntity CreateProduct(GameContext context, GameEntity company, NicheType niche)
        {
            company.AddProduct(niche, 0);

            // positioning
            int positionings = Markets.GetNichePositionings(niche, context).Count;

            company.AddProductPositioning(Random.Range(0, positionings));

            // development
            company.AddFeatures(new Dictionary <ProductFeature, int> {
                [ProductFeature.Acquisition] = 0, [ProductFeature.Monetisation] = 0, [ProductFeature.Retention] = 0
            }, 0);
            company.AddExpertise(Random.Range(1, 4));

            company.AddFinancing(new Dictionary <Financing, int> {
                [Financing.Development] = 0, [Financing.Marketing] = 0, [Financing.Team] = 0
            });

            // clients
            var flow        = Marketing.GetBaseClientsForNewCompanies(context, niche);
            var baseClients = Random.Range(0.15f, 0.35f) * flow;

            company.AddMarketing((long)baseClients);

            // sphere of interest
            var industry = Markets.GetIndustry(niche, context);

            AddFocusNiche(niche, company, context);
            AddFocusIndustry(industry, company);


            Investments.SetCompanyGoal(context, company, InvestorGoal.Operationing);

            return(company);
        }
 private static long GetGroupMaintenance(GameContext context, GameEntity company)
 {
     return(Investments.GetHoldings(company, context, true)
            .Sum(h => h.control * GetMaintenance(context, h.company) / 100));
 }
示例#18
0
 public static bool IsInvestsInCompany(GameEntity company, int investorId)
 {
     return(Investments.IsInvestsInCompany(investorId, company));
     //return company.shareholders.Shareholders.ContainsKey(investorId);
 }
示例#19
0
 public static bool IsInvestsInCompany(GameEntity company, GameEntity investor) => Investments.IsInvestsInCompany(investor, company);
示例#20
0
 public static void AddMoneyToInvestor(GameContext context, int investorId, long sum)
 {
     Investments.AddMoneyToInvestor(context, investorId, sum);
 }
示例#21
0
        public static long OnGoalCompletion(GameEntity startup, InvestorType investorType)
        {
            bool goalCompleted = !Investments.IsInvestorSuitableByGoal(investorType, startup.companyGoal.InvestorGoal);

            return(goalCompleted ? Balance.COMPANY_DESIRE_TO_SELL_YES : Balance.COMPANY_DESIRE_TO_SELL_NO);
        }
示例#22
0
 public static GameEntity GetInvestorById(GameContext context, int investorId)
 {
     return(Investments.GetInvestor(context, investorId));
 }
示例#23
0
        public static GameEntity GetSelectedInvestor(GameContext gameContext)
        {
            var id = GetScreenParameter(gameContext, C.MENU_SELECTED_INVESTOR);

            return(Investments.GetInvestor(gameContext, (int)id));
        }
示例#24
0
        public static GameEntity GetSelectedInvestor(GameContext gameContext)
        {
            int id = (int)GetScreenData(gameContext)[Balance.MENU_SELECTED_INVESTOR];

            return(Investments.GetInvestorById(gameContext, id));
        }
示例#25
0
        public static long GetInvestorCapitalCost(GameContext gameContext, GameEntity human)
        {
            var holdings = Investments.GetHoldings(human, gameContext, false);

            return(Economy.GetHoldingsCost(gameContext, holdings));
        }
示例#26
0
 public static long GetHoldingsCost(GameContext context, GameEntity entity) => GetHoldingsCost(context, Investments.GetHoldings(entity, context, true));
示例#27
0
 public static int GenerateInvestorId(GameContext context)
 {
     return(Investments.GenerateInvestorId(context));
 }
 private static long GetGroupIncome(GameContext context, GameEntity e)
 {
     return(Investments.GetHoldings(e, context, true)
            .Sum(h => h.control * GetIncome(context, h.company) / 100));
 }
 public static GameEntity[] GetDaughters(GameEntity c, GameContext context)
 {
     return(Investments.GetOwnings(c, context));
 }