public static int GetFeatureUpgradeCost(GameEntity company, TeamTask teamTask)
{
var task = teamTask as TeamTaskFeatureUpgrade;
var cost = Products.GetFeatureRating(company, task.NewProductFeature.Name);
return 1 + (int)cost;
}
void RenderFeatureUpgradeCost(GameEntity company, TeamTask task)
{
if (UpgradeCost != null)
{
UpgradeCost.text = Teams.GetFeatureUpgradeCost(company, task).ToString();
}
}
public async Task <TeamTask> InsertTeamTaskAsync(TeamTask teamTask)
{
_context.TeamTasks.Add(teamTask);
await _context.SaveChangesAsync();
return(teamTask);
}
public void SetEntity(TeamInfo info, int teamId, TeamTask task = null)
{
this.teamId = teamId;
var max = C.TASKS_PER_TEAM;
var company = Flagship;
var chosenSlots = company.team.Teams[teamId].Tasks.Count;
freeSlots = max - chosenSlots;
TeamInfo = info;
TeamType = info.TeamType;
TeamName.text = info.Name;
ChooseHireManagersOfTeam.SetEntity(teamId);
TeamTypeImage.sprite = GetTeamTypeSprite();
if (task != null)
{
RenderTaskAssignTeamView(task, info);
}
else
{
RenderDefaultTeamView(chosenSlots, info);
}
}
public static int GetSlotsForTask(TeamInfo team, TeamTask task)
{
if (IsUniversalTeam(team.TeamType))
{
return(GetTeamTasks(team));
}
return(GetTeamTasks(team) * 2);
}
public void SetEntity(TeamTask t)
{
bool canHireSpecialisedTeams = Flagship.team.Teams.Count > 1;
//Draw(NewTeamButton, Teams.IsTaskSuitsTeam(TeamType.SmallCrossfunctionalTeam, t));
Draw(DevTeamButton, canHireSpecialisedTeams && t.IsFeatureUpgrade);
Draw(MarketingTeamButton, canHireSpecialisedTeams && t.IsMarketingTask);
Draw(SupportTeamButton, canHireSpecialisedTeams && t.IsSupportTask && false);
Draw(ServersideTeamButton, false && canHireSpecialisedTeams && t.IsHighloadTask); // && Teams.IsTaskSuitsTeam(TeamType.DevelopmentTeam, t)
}
public void SetEntity(TeamTask teamTask, int SlotId)
{
this.teamTask = teamTask;
var slot = Teams.GetSlotOfTeamTask(Flagship, teamTask);
this.SlotId = slot.SlotId;
TeamId = 0;
ViewRender();
}
void RenderTaskAssignTeamView(TeamTask task, TeamInfo info)
{
if (task.IsFeatureUpgrade)
{
var maxLevel = Products.GetFeatureRatingCap(Flagship); // Random.Range(4, 10);
var gain = Products.GetFeatureRatingGain(Flagship);
Text1.text = Visuals.Positive(gain.ToString("+0.0")); // from organisation
Text2.text = $"{maxLevel.ToString("0.0")} lvl";
Text2.color = Visuals.GetGradientColor(0, 10, maxLevel);
Text3.text = $"";
}
if (task.IsMarketingTask)
{
var marketingEfficiency = Teams.GetMarketingEfficiency(Flagship);
var channelId = (task as TeamTaskChannelActivity).ChannelId;
var baseGain = Marketing.GetChannelClientGain(Flagship, channelId);
var finalGain = baseGain * marketingEfficiency / 100;
Text1.text = $"{marketingEfficiency}%";
Text1.color = Visuals.GetGradientColor(50, 150, marketingEfficiency);
Text2.text = $"+{Format.Minify(finalGain)} users"; // from organisation
Text2.color = Visuals.Positive(); // Visuals.GetGradientColor(50, 150, marketingEfficiency);
Text3.text = $"";
Text3.color = Visuals.Neutral();
}
if (task.IsHighloadTask)
{
Text1.text = $"";
//Text1.color = Visuals.GetGradientColor(5, 20, iterationSpeed);
Text1.color = Visuals.GetColorFromString(Colors.COLOR_NEUTRAL);
Text2.text = $"";
Text2.color = Visuals.GetColorFromString(Colors.COLOR_NEUTRAL);
Text3.text = $"";
Text3.color = Visuals.GetColorFromString(Colors.COLOR_NEUTRAL);
}
Text4.text = $"{(freeSlots == 0 ? "NO" : freeSlots.ToString())}";
Text4.color = Visuals.GetColorPositiveOrNegative(freeSlots > 0);
}
public static bool CanExecuteTeamTask(GameEntity company, TeamTask teamTask, GameContext gameContext)
{
var taskCost = GetTaskCost(company, teamTask, gameContext);
if (teamTask.IsFeatureUpgrade)
return Companies.IsEnoughResources(company, taskCost);
if (teamTask.IsMarketingTask)
{
var payer = Companies.GetPayer(company, gameContext);
return Companies.IsEnoughResources(payer, taskCost);
}
return true;
}
public static void ProcessTeamTaskIfNotPending(GameEntity p, int date, TeamTask task, ref List<SlotInfo> removableTasks, int slotId, int teamId)
{
if (task.IsPending)
return;
if (task is TeamTaskChannelActivity)
{
// channel tookout
// campaign expired
if (task.EndDate <= date)
{
removableTasks.Add(new SlotInfo { SlotId = slotId, TeamId = teamId });
}
}
}
public override void ViewRender()
{
base.ViewRender();
var company = Flagship;
var relay = FindObjectOfType <FlagshipRelayInCompanyView>();
task = relay.TeamTask;
var teams = company.team.Teams;
RenderTableLabels(task);
SetItems(teams.OrderByDescending(t => 4 - t.Tasks.Count));
}
public static long GetTeamTaskCost(GameEntity product, TeamTask teamTask)
{
return(0);
if (teamTask.IsFeatureUpgrade)
{
return(0);
}
if (teamTask.IsMarketingTask)
{
return((teamTask as TeamTaskChannelActivity).ChannelCost);
}
//return Marketing.GetMarketingActivityCost(product, gameContext, (teamTask as TeamTaskChannelActivity).ChannelId);
return(0);
}
public static TeamResource GetTaskCost(GameEntity company, TeamTask teamTask, GameContext gameContext)
{
if (teamTask.IsFeatureUpgrade)
{
var cost = GetFeatureUpgradeCost(company, teamTask);
return new TeamResource(0, 0, 0, cost, 0);
}
if (teamTask.IsMarketingTask)
{
var cost = Marketing.GetChannelCost(company, (teamTask as TeamTaskChannelActivity).ChannelId);
return new TeamResource(cost);
}
return new TeamResource(0);
}
public bool AreSameTypeTasks(TeamTask t)
{
if (IsFeatureUpgrade && t.IsFeatureUpgrade)
{
return(true);
}
if (IsMarketingTask && t.IsMarketingTask)
{
return(true);
}
if (IsHighloadTask && t.IsHighloadTask)
{
return(true);
}
return(false);
}
void RenderTableLabels(TeamTask task)
{
if (task.IsFeatureUpgrade)
{
RenderLabels("Feature gain", "Max feature level", "", "Available tasks");
}
if (task.IsHighloadTask)
{
RenderLabels("", "", "", "Available tasks");
//RenderLabels("Break chance", "Install time", "", "Free task slots");
}
if (task.IsMarketingTask)
{
RenderLabels("Efficiency", "Final gain", "", "Available tasks");
//RenderLabels("Effeciency", "Final gain", "", "Free task slots");
}
}
public static int GetPendingSameTypeTaskAmount(GameEntity product, TeamTask task)
{
if (task.IsFeatureUpgrade)
{
return(GetPendingFeaturesAmount(product));
}
if (task.IsMarketingTask)
{
return(GetPendingMarketingChannelsAmount(product));
}
if (task.IsHighloadTask)
{
return(GetPendingServersAmount(product));
}
return(0);
}
public static SlotInfo GetSlotOfTeamTask(GameEntity product, TeamTask task)
{
for (var teamId = 0; teamId < product.team.Teams.Count; teamId++)
{
var t = product.team.Teams[teamId];
for (var slotId = 0; slotId < t.Tasks.Count; slotId++)
{
if (t.Tasks[slotId] == task)
{
return(new SlotInfo {
SlotId = slotId, TeamId = teamId
});
}
}
}
return(null);
}
public async Task <TeamTask> UpdateTeamTaskAsync(string id, TeamTask s)
{
var teamTask = await _context.TeamTasks.FindAsync(id);
if (teamTask == null)
{
return(null);
}
teamTask.TeamName = s.TeamName;
teamTask.Value = s.Value;
teamTask.Points = s.Points;
teamTask.Date = s.Date;
teamTask.Attempts = s.Attempts;
teamTask.ItemNumber = s.ItemNumber;
_context.TeamTasks.Update(teamTask);
await _context.SaveChangesAsync();
return(teamTask);
}
static void DisableTask(GameEntity product, GameContext gameContext, TeamTask task)
{
//Debug.Log($"Disabling task {task.ToString()} from {product.company.Name}");
if (task.IsMarketingTask)
{
var activity = task as TeamTaskChannelActivity;
var channel = Markets.GetMarketingChannel(gameContext, activity.ChannelId);
Marketing.DisableChannelActivity(product, channel);
}
if (task.IsFeatureUpgrade)
{
var activity = task as TeamTaskFeatureUpgrade;
//var channel = Markets.GetMarketingChannels(gameContext).First(c => c.marketingChannel.ChannelInfo.ID == activity.ChannelId);
//Products.DisableChannelActivity(product, gameContext, channel);
}
if (task.IsHighloadTask || task.IsSupportTask)
{
var activity = task as TeamTaskSupportFeature;
var upgrades = product.supportUpgrades.Upgrades;
var name = activity.SupportFeature.Name;
if (upgrades.ContainsKey(name))
{
upgrades[name]--;
}
if (upgrades[name] <= 0)
{
upgrades.Remove(name);
}
}
}
public List <TeamTask> GetTasks(int teamMemberId, ControllerBase cBase, ref IActionResult actionResult)
{
List <TeamTask> result = new List <TeamTask>();
string sqlString = "Select * From Task Where IdCreator = @teamMemberId;";
using (SqlConnection con = new SqlConnection(connectionString))
{
using (var com = new SqlCommand(sqlString))
{
com.Connection = con;
com.CommandText = sqlString;
com.Parameters.AddWithValue("teamMemberId", teamMemberId);
con.Open();
var dr = com.ExecuteReader();
while (dr.Read())
{
TeamTask teamTask = new TeamTask();
teamTask.name = dr["Name"].ToString();
teamTask.description = dr["Description"].ToString();
teamTask.deadline = dr["Deadline"].ToString();
teamTask.taskType = dr["IdTaskType"].ToString();
//teamTask.projectName = dr["projectName"].ToString();
result.Add(teamTask);
//id = int.Parse(dr["Id"].ToString()) + 1;
}
}
}
if (result.Count == 0)
{
actionResult = cBase.NotFound("Not found");
}
return(result);
}
public bool AreSameTasks(TeamTask t)
{
if (!AreSameTypeTasks(t))
{
return(false);
}
if (IsFeatureUpgrade && ((TeamTaskFeatureUpgrade)this)?.NewProductFeature.Name == ((TeamTaskFeatureUpgrade)t)?.NewProductFeature.Name)
{
return(true);
}
if (IsMarketingTask && ((TeamTaskChannelActivity)this).ChannelId == ((TeamTaskChannelActivity)t).ChannelId)
{
return(true);
}
if (IsHighloadTask && ((TeamTaskSupportFeature)this).SupportFeature.Name == ((TeamTaskSupportFeature)t).SupportFeature.Name)
{
return(true);
}
return(false);
}
public void AddPendingTask(TeamTask teamTask)
{
TeamTask = teamTask;
//ScheduleUtils.PauseGame(Q);
if (Teams.AddTeamTask(Flagship, CurrentIntDate, Q, 0, teamTask))
{
if (teamTask.IsFeatureUpgrade)
{
SoundManager.Play(Sound.ProgrammingTask);
}
if (teamTask.IsMarketingTask)
{
//SoundManager.Play(Sound.MarketingTask);
}
if (teamTask.IsHighloadTask)
{
SoundManager.Play(Sound.ServerTask);
}
}
}
internal void SetTask(TeamTask task, int ID)
{
TeamTask = task;
this.ID = ID;
}
public static int GetMaxSlotsForTaskType(GameEntity product, TeamTask task)
{
return(product.team.Teams.Sum(t => GetSlotsForTask(t, task)));
}
public static int GetOverallSlotsForTaskType(GameEntity product, TeamTask task)
{
return(GetMaxSlotsForTaskType(product, task) - GetActiveSameTaskTypeSlots(product, task)); // GetAllActiveTaskSlots(product);
}
public static int GetActiveSameTaskTypeSlots(GameEntity product, TeamTask task)
{
return(product.team.Teams[0].Tasks.Count(t => task.AreSameTypeTasks(t) && !t.IsPending));
}
public static int GetAllSameTaskTypeSlots(GameEntity product, TeamTask task)
{
return(product.team.Teams[0].Tasks.Count(task.AreSameTypeTasks));
}
public void SetEntity(int teamId, TeamTask teamTask)
{
this.teamId = teamId;
this.teamTask = teamTask;
ChosenTaskLabel.SetTask(teamTask);
Draw(ChosenTaskLabel, true);
Draw(RemoveTaskButton, true);
Draw(RemoveFeatureButton, teamTask.IsFeatureUpgrade);
var team = Flagship.team.Teams[teamId];
TaskBenefit.text = "";
if (teamTask.IsPending)
{
TaskBenefit.text = Visuals.Negative("<size=30>This task is not active!</size>") + "\nCause our team is doing other tasks. Hire more teams, to make more tasks at the same time.\n\n";
}
if (teamTask.IsFeatureUpgrade)
{
var f = teamTask as TeamTaskFeatureUpgrade;
var segments = Marketing.GetAudienceInfos();
float sumLoyalty = 0;
float sumLoyaltyMax = 0;
float sumLoyaltyABS = 0;
var featureDescription = "";
var rating = Products.GetFeatureRating(Flagship, f.NewProductFeature.Name);
var ratingColor = Visuals.GetGradientColor(0, 10f, rating);
foreach (var s in segments)
{
var segmentId = s.ID;
var maxBenefit = Marketing.GetLoyaltyChangeFromFeature(Flagship, f.NewProductFeature, segmentId, true);
var benefit = Marketing.GetLoyaltyChangeFromFeature(Flagship, f.NewProductFeature, segmentId, false);
sumLoyalty += benefit;
sumLoyaltyMax += maxBenefit;
sumLoyaltyABS += Mathf.Abs(benefit);
var maxBenefitFormatted = Visuals.Colorize(maxBenefit.ToString("+0;-#"), maxBenefit >= 0);
var benefitFormatted = Visuals.Colorize(benefit.ToString("+0.0;-#"), ratingColor);
//if (benefit != 0)
// featureDescription += $"\n\n{maxBenefitFormatted} loyalty for {s.Name}\n\t<i>currently</i>: {benefitFormatted}";
//else
// featureDescription += "\n\nNo effects";
}
if (f.NewProductFeature.FeatureBonus.isRetentionFeature)
{
}
if (f.NewProductFeature.FeatureBonus.isMonetisationFeature)
{
var monetisationBenefit = Products.GetFeatureActualBenefit(Flagship, f.NewProductFeature); // f.NewProductFeature.FeatureBonus.Max;
var monetisationBenefitMax = f.NewProductFeature.FeatureBonus.Max;
featureDescription += Visuals.Positive("\n\nLoyalty will increase after upgrading this feature");
featureDescription += $"\n\n{Visuals.Positive($"Increases income by +{monetisationBenefit.ToString("0.0")}% (max: +{monetisationBenefitMax}%)")}";
}
var sumLoyaltyFormatted = Visuals.Colorize(sumLoyalty.ToString("+0.0;-#"), sumLoyalty >= 0);
var sumLoyaltyMaxFormatted = Visuals.Colorize(sumLoyaltyMax.ToString("+0.0;-#"), sumLoyaltyMax >= 0);
var ratingFormatted = Visuals.Colorize(rating.ToString("0.0"), ratingColor);
var ratingCap = Products.GetFeatureRatingCap(Flagship);
TaskBenefit.text += $"<size=40>Feature Quality: {ratingFormatted}lvl</size>" +
$"\n\nThis feature will be upgraded to level {ratingCap}" +
$"\n\n<size=30>Gives you {sumLoyaltyFormatted} loyalty total</size>" +
//$"\n\nOn quality=10 you will get:" +
//$"\n\n<size=30>{sumLoyaltyMaxFormatted} loyalty total</size>" +
$"\n{featureDescription}"
;
TaskModifiers.text = $"Will be upgraded to level {ratingCap} due to assigned team";
}
if (teamTask.IsMarketingTask)
{
TaskBenefit.text += $"Marketing task";
TaskModifiers.text = "";
}
if (teamTask.IsHighloadTask)
{
TaskBenefit.text += $"Server";
TaskModifiers.text = "";
}
//TaskExecutor.text = $"<b>{Visuals.Link(team.Name)}</b>";
}
public static void InitializeTeamTaskIfNotPending(GameEntity product, int date, GameContext gameContext, TeamTask task)
{
if (task.IsPending)
return;
task.StartDate = date;
if (task.IsMarketingTask)
{
var channelId = (task as TeamTaskChannelActivity).ChannelId;
var channel = Markets.GetMarketingChannel(gameContext, channelId);
if (!Marketing.IsActiveInChannel(product, channelId))
{
var cost = Marketing.GetChannelCost(product, channelId);
var payer = Companies.GetPayer(product, gameContext);
if (Companies.Pay(payer, cost, "Marketing " + channel))
{
Marketing.EnableChannelActivity(product, channel);
var gain = Marketing.GetChannelClientGain(product, channelId);
Marketing.AddClients(product, gain);
var duration = Marketing.GetCampaignDuration(product, gain);
task.EndDate = date + duration;
}
}
}
}
public void SetTask(TeamTask teamTask)
{
TeamTask = teamTask;
ViewRender();
}
