public async Task <IActionResult> Edit(int id, [Bind("ID,Name,UserID,DepartGarageID,ArrivalGarageID,DriverID,VehicleID,BeginTime,EndTime,IsActive")] Expeditions expeditions)
{
if (id != expeditions.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(expeditions);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ExpeditionsExists(expeditions.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(expeditions));
}
public void Update(RawMasterInfo rpInfo)
{
Ships.UpdateRawData(rpInfo.Ships, r => new ShipInfo(r), (rpData, rpRawData) => rpData.Update(rpRawData));
ShipTypes.UpdateRawData(rpInfo.ShipTypes, r => new ShipTypeInfo(r), (rpData, rpRawData) => rpData.Update(rpRawData));
Equipment.UpdateRawData(rpInfo.Equipment, r => new EquipmentInfo(r), (rpData, rpRawData) => rpData.Update(rpRawData));
EquipmentTypes.UpdateRawData(rpInfo.EquipmentTypes, r => new EquipmentTypeInfo(r), (rpData, rpRawData) => rpData.Update(rpRawData));
Items.UpdateRawData(rpInfo.Items, r => new ItemInfo(r), (rpData, rpRawData) => rpData.Update(rpRawData));
MapAreas.UpdateRawData(rpInfo.MapAreas, r => new MapAreaInfo(r), (rpData, rpRawData) => rpData.Update(rpRawData));
Maps.UpdateRawData(rpInfo.Maps, r => new MapMasterInfo(r), (rpData, rpRawData) => rpData.Update(rpRawData));
Expeditions.UpdateRawData(rpInfo.Expeditions, r => new ExpeditionInfo(r), (rpData, rpRawData) => rpData.Update(rpRawData));
EventMapCount = (from rArea in MapAreas.Values
where rArea.IsEventArea
join rMap in Maps.Values on rArea.ID equals rMap.AreaID
select rMap).Count();
if (r_InitializationLock != null)
{
r_InitializationLock.Set();
r_InitializationLock.Dispose();
r_InitializationLock = null;
}
}
public IActionResult BiletAl(int sefer_id, int user_id, double fiyat)
{
Tickets bilet = new Tickets();
bilet.SeatNumber = 1;
bilet.Status = true;
bilet.UserId = user_id;
bilet.ExpeditionId = sefer_id;
bilet.TicketPrice = fiyat;
_context.Add(bilet);
_context.SaveChanges();
Expeditions sefer = new Expeditions();
sefer = _context.Expeditions.Where(x => x.Id == sefer_id).FirstOrDefault();
int biletSayısı = _context.Tickets.Where(x => x.ExpeditionId == sefer_id && x.Status == true).Count();
if (biletSayısı % 5 == 0)
{
double yeniFiyat = sefer.Price + ((sefer.Price * 10) / 100);
sefer.Price = yeniFiyat;
_context.SaveChanges();
}
int id = user_id;
string message = "Biletiniz Alındı...";
return(RedirectToAction("Index", "Home", new { id, message }));
}
public async Task <IActionResult> Create([Bind("ID,Name,UserID,DepartGarageID,ArrivalGarageID,DriverID,VehicleID,BeginTime,EndTime,IsActive")] Expeditions expeditions)
{
if (ModelState.IsValid)
{
_context.Add(expeditions);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(expeditions));
}
public CitySaveData Save_Data()
{
return(new CitySaveData()
{
Name = Name,
Cash = Cash,
Buildings = new List <BuildingSaveData>(),
Contacts = Contacts.Instance.Save(),
Expeditions = Expeditions.Select(x => new ExpeditionSaveData()
{
Goal = (int)x.Goal, Lenght = (int)x.Lenght, Building_Id = x.Building_Id, Resource = x.Resource != null ? (int)x.Resource.Type : -1,
State = (int)x.State, Time_Remaining = x.Time_Remaining, Colony_Data = x.Colony_Data == null ? null : x.Colony_Data.Save_Data
}).ToList(),
Colony_Locations = Colony_Locations.Select(x => x.Save_Data).ToList()
});
}
public override void OnInitialized()
{
var rMasterInfo = KanColleGame.Current.MasterInfo;
using (var rCommand = CreateCommand())
{
rCommand.CommandText = "SELECT DISTINCT expedition FROM expedition ORDER BY expedition;";
using (var rReader = rCommand.ExecuteReader())
{
var rExpeditions = new List <ExpeditionInfo>(rReader.VisibleFieldCount);
while (rReader.Read())
{
ExpeditionInfo rExpedition;
if (rMasterInfo.Expeditions.TryGetValue(rReader.GetInt32(0), out rExpedition))
{
rExpeditions.Add(rExpedition);
}
}
Expeditions.AddRange(rExpeditions);
}
}
}
public void Update(float delta_time)
{
DiagnosticsManager.Instance.Message(GetType(), "--- UPDATE STARTS ---");
DiagnosticsManager.Instance.Start(GetType(), "total", "Total");
DiagnosticsManager.Instance.Start(GetType(), "expeditions", "Expeditions");
if (grace_time_remaining > 0.0f)
{
grace_time_remaining = Math.Max(grace_time_remaining - TimeManager.Instance.Seconds_To_Days(delta_time), 0.0f);
}
//TODO: Add stopwatch?
//Expeditions
foreach (Expedition expedition in Expeditions)
{
expedition.Update(delta_time);
}
DiagnosticsManager.Instance.End(GetType(), "expeditions");
DiagnosticsManager.Instance.Start(GetType(), "buildings", "Buildings");
//Buildings
foreach (Building building in Buildings)
{
if (building is Residence)
{
(building as Residence).Update(delta_time);
}
else
{
building.Update(delta_time);
}
}
foreach (Building building in removed_buildings)
{
Buildings.Remove(building);
}
removed_buildings.Clear();
foreach (Building building in added_buildings)
{
Buildings.Add(building);
}
added_buildings.Clear();
foreach (Expedition expedition in removed_expeditions)
{
Expeditions.Remove(expedition);
}
removed_expeditions.Clear();
foreach (Expedition expedition in added_expeditions)
{
Expeditions.Add(expedition);
}
added_expeditions.Clear();
DiagnosticsManager.Instance.End(GetType(), "buildings");
DiagnosticsManager.Instance.Start(GetType(), "statistics", "Update statistics");
//Update statistics
foreach (Resource resource in Resource.All)
{
Resource_Totals[resource] = 0.0f;
Usable_Resource_Totals[resource] = 0.0f;
Resource_Max_Storage[resource] = 0.0f;
Resource_Delta[resource] = 0.0f;
}
Cash_Delta = 0.0f;
Food_Current = 0.0f;
Food_Max = 0.0f;
Food_Produced = 0.0f;
Food_Consumed = 0.0f;
Food_Delta = 0.0f;
Dictionary <Building.Resident, int> current_population = new Dictionary <Building.Resident, int>();
Dictionary <Building.Resident, int> max_population = new Dictionary <Building.Resident, int>();
Dictionary <Building.Resident, float> happiness = new Dictionary <Building.Resident, float>();
Dictionary <Building.Resident, int> workers_required = new Dictionary <Building.Resident, int>();
Dictionary <Building.Resident, int> available_workers = new Dictionary <Building.Resident, int>();
Dictionary <Building.Resident, float> total_education = new Dictionary <Building.Resident, float>();
foreach (Building.Resident resident in Enum.GetValues(typeof(Building.Resident)))
{
current_population.Add(resident, 0);
max_population.Add(resident, 0);
happiness.Add(resident, 0.0f);
workers_required.Add(resident, 0);
available_workers.Add(resident, 0);
total_education.Add(resident, 0.0f);
}
foreach (Building building in Buildings)
{
foreach (KeyValuePair <Resource, float> pair in building.Storage)
{
Resource_Totals[pair.Key] += pair.Value;
Usable_Resource_Totals[pair.Key] += pair.Value;
if (pair.Key.Is_Food)
{
Food_Current += pair.Value;
}
}
foreach (KeyValuePair <Resource, float> pair in building.Input_Storage)
{
Resource_Totals[pair.Key] += pair.Value;
if (pair.Key.Is_Food)
{
Food_Current += pair.Value;
}
}
foreach (KeyValuePair <Resource, float> pair in building.Output_Storage)
{
Resource_Totals[pair.Key] += pair.Value;
if (pair.Key.Is_Food)
{
Food_Current += pair.Value;
}
}
foreach (KeyValuePair <Resource, float> pair in building.Per_Day_Resource_Delta)
{
Resource_Delta[pair.Key] += pair.Value;
}
foreach (KeyValuePair <Resource, float> pair in building.Total_Max_Storage)
{
Resource_Max_Storage[pair.Key] += pair.Value;
if (pair.Key.Is_Food)
{
Food_Max += pair.Value;
}
}
Cash_Delta += building.Per_Day_Cash_Delta;
Food_Produced += building.Food_Production_Per_Day;
Food_Delta += building.Food_Production_Per_Day;
if (building is Residence)
{
Food_Consumed += (building as Residence).Food_Consumed;
Food_Delta -= (building as Residence).Food_Consumed;
}
if (building.Is_Complete)
{
if (building is Residence && building.Is_Operational)
{
Residence residence = building as Residence;
foreach (Building.Resident resident in Enum.GetValues(typeof(Building.Resident)))
{
current_population[resident] += residence.Current_Residents[resident];
available_workers[resident] += residence.Available_Work_Force[resident];
max_population[resident] += residence.Resident_Space[resident];
happiness[resident] += residence.Happiness[resident] * residence.Current_Residents[resident];
total_education[resident] += residence.Education(resident) * residence.Current_Residents[resident];
}
}
if (building.Requires_Workers && building.Is_Complete && (building.Is_Connected || !building.Requires_Connection) && (!building.Is_Paused || PAUSED_BUILDINGS_KEEP_WORKERS))
{
foreach (Building.Resident resident in Enum.GetValues(typeof(Building.Resident)))
{
workers_required[resident] += building.Worker_Settings[resident];
}
}
}
}
DiagnosticsManager.Instance.End(GetType(), "statistics");
DiagnosticsManager.Instance.Start(GetType(), "workers", "Allocate workers");
//Allocate workers
Dictionary <Building.Resident, float> worker_ratios = new Dictionary <Building.Resident, float>();
Dictionary <Building.Resident, int> workers_allocated = new Dictionary <Building.Resident, int>();
foreach (Building.Resident resident in Enum.GetValues(typeof(Building.Resident)))
{
worker_ratios.Add(resident, workers_required[resident] == 0 ? 0.0f : current_population[resident] / (float)workers_required[resident]);
workers_allocated.Add(resident, 0);
}
foreach (Building building in Buildings)
{
if (!building.Requires_Workers)
{
continue;
}
foreach (Building.Resident resident in Enum.GetValues(typeof(Building.Resident)))
{
building.Current_Workers[resident] = 0;
}
if (!(building.Is_Complete && (building.Is_Connected || !building.Requires_Connection) && (!building.Is_Paused || PAUSED_BUILDINGS_KEEP_WORKERS)))
{
continue;
}
if (building.Is_Complete && (building.Is_Connected || !building.Requires_Connection) && (!building.Is_Paused || PAUSED_BUILDINGS_KEEP_WORKERS))
{
foreach (Building.Resident resident in Enum.GetValues(typeof(Building.Resident)))
{
int workers = Mathf.RoundToInt(building.Worker_Settings[resident] * Mathf.Clamp(worker_ratios[resident], 0.0f, 1.0f));
if (workers > available_workers[resident])
{
workers = available_workers[resident];
}
building.Current_Workers[resident] = workers;
available_workers[resident] -= workers;
workers_allocated[resident] += workers;
if (available_workers[resident] < 0)
{
CustomLogger.Instance.Error("More workers allocated, than there is available workers");
}
}
}
}
foreach (Building building in Buildings)
{
if (!building.Requires_Workers || !(building.Is_Complete && (building.Is_Connected || !building.Requires_Connection) && (!building.Is_Paused || PAUSED_BUILDINGS_KEEP_WORKERS)))
{
continue;
}
foreach (Building.Resident resident in Enum.GetValues(typeof(Building.Resident)))
{
if (available_workers[resident] > 0 && worker_ratios[resident] < 1.0f && building.Current_Workers[resident] < building.Worker_Settings[resident])
{
building.Current_Workers[resident]++;
available_workers[resident]--;
workers_allocated[resident]++;
}
}
}
foreach (Building.Resident resident in Enum.GetValues(typeof(Building.Resident)))
{
if (available_workers[resident] > 0 && workers_allocated[resident] < workers_required[resident])
{
CustomLogger.Instance.Error("Worker allocation mismatch, not enough allocated");
}
if (workers_allocated[resident] > workers_required[resident])
{
CustomLogger.Instance.Error("Worker allocation mismatch, too many allocated");
}
if (workers_allocated[resident] > current_population[resident])
{
CustomLogger.Instance.Error("Worker allocation mismatch, allocated > population");
}
}
DiagnosticsManager.Instance.End(GetType(), "workers");
DiagnosticsManager.Instance.Start(GetType(), "walkers", "Spawn walkers");
//Spawn walkers
int max = Spawn_Walkers ? Mathf.Min(Mathf.RoundToInt((current_population[Building.Resident.Peasant] + current_population[Building.Resident.Citizen] + current_population[Building.Resident.Noble]) / 30.0f) + 1, 10) : 0;
if (Walkers.Count < max)
{
List <Building> possible_buildings = Buildings.Where(x => x.Is_Connected && x.Requires_Connection && x.Is_Operational && !x.Is_Road && x.Entities_Spawned.Count == 0).ToList();
if (possible_buildings.Count > 25) //TODO
//TODO: Implement faster pathfinding A* ?
{
if (Buildings.Count <= 1)
{
//Use pathfinding for paths
Building spawner = RNG.Instance.Item(possible_buildings);
possible_buildings.Remove(spawner);
if (possible_buildings.Count >= 1)
{
Building road = null;
foreach (Building b in Map.Instance.Get_Buildings_Around(spawner))
{
if (b.Is_Road && b.Is_Built && b.Is_Connected)
{
road = b;
break;
}
}
if (road != null)
{
Building target_building = RNG.Instance.Item(possible_buildings);//TODO: allow x.Entities_Spawned.Count != 0 in this list
Building target_road = null;
foreach (Building b in Map.Instance.Get_Buildings_Around(target_building))
{
if (b.Is_Road && b.Is_Built && b.Is_Connected)
{
target_road = b;
break;
}
}
if (target_road != null)
{
List <PathfindingNode> path = Pathfinding.Path(Map.Instance.Road_Pathing, road.Tile.PathfindingNode, target_road.Tile.Road_PathfindingNode, false);
if (path.Count > 2)
{
Entity walker = new Entity(EntityPrototypes.Instance.Get("walker"), road.Tile, spawner);
walker.Set_Path(path, 0.5f);
Walkers.Add(walker);
}
}
}
}
}
else
{
//Use connected buildings for paths
Tile spawn = null;
Building spawner = null;
List <PathfindingNode> path = Entity.Find_Walker_City_Path(out spawn, out spawner);
if (path != null)
{
Entity walker = new Entity(EntityPrototypes.Instance.Get("walker"), spawn, spawner);
walker.Set_Path(path, 0.5f);
Walkers.Add(walker);
}
}
}
}
DiagnosticsManager.Instance.End(GetType(), "walkers");
DiagnosticsManager.Instance.Start(GetType(), "ships", "Spawn ships");
//Spawn ships
if (Map.Instance.Ship_Spawns.Count > 0)
{
ship_spawn_cooldown -= delta_time * TimeManager.Instance.Multiplier;
if (ship_spawn_cooldown <= 0.0f)
{
ship_spawn_cooldown += 120.0f * (200.0f / (100.0f + ((0.5f * current_population[Building.Resident.Peasant]) + (1.5f * current_population[Building.Resident.Citizen]) + current_population[Building.Resident.Noble]))) *
(RNG.Instance.Next(50, 150) * 0.01f);
foreach (Building building in Buildings)
{
if (!building.Data.ContainsKey(Building.DOCK_ID_KEY))
{
continue;
}
Building dock = Buildings.FirstOrDefault(x => x.Id == long.Parse(building.Data[Building.DOCK_ID_KEY]));
if (dock == null || ships.ContainsKey(dock) || building.Tags.Contains(Building.Tag.Creates_Expeditions) || !building.Is_Operational)
{
continue;
}
Tile spawn = RNG.Instance.Item(Map.Instance.Ship_Spawns);
Tile target = null;
foreach (Tile t in Map.Instance.Get_Adjanced_Tiles(dock.Tile).Select(x => x.Value).ToArray())
{
if (t.Building == null && t.Has_Ship_Access)
{
target = t;
break;
}
}
if (target == null)
{
break;
}
List <PathfindingNode> path = Pathfinding.Path(Map.Instance.Ship_Pathing, spawn.Ship_PathfindingNode, target.Ship_PathfindingNode, false);
if (path.Count > 2)
{
List <PathfindingNode> return_path = Pathfinding.Path(Map.Instance.Ship_Pathing, target.Ship_PathfindingNode, spawn.Ship_PathfindingNode, false);
path.AddRange(return_path.Where(x => !x.Coordinates.Equals(target.Coordinates)).ToList());
Entity ship = new Entity(EntityPrototypes.Instance.Get("ship"), spawn, dock);
ship.Set_Path(path, 0.75f);
ship.Add_Order(new Entity.PathOrder(target.Ship_PathfindingNode, 20.0f));
ships.Add(dock, ship);
}
}
}
}
DiagnosticsManager.Instance.End(GetType(), "ships");
DiagnosticsManager.Instance.Start(GetType(), "gui", "Update GUI");
//GUI
int peasant_current = current_population[Building.Resident.Peasant];
int peasant_max = max_population[Building.Resident.Peasant];
float peasant_happiness = peasant_current > 0 ? happiness[Building.Resident.Peasant] / peasant_current : 0.0f;
Happiness[Building.Resident.Peasant] = peasant_happiness;
int peasant_employment = workers_allocated[Building.Resident.Peasant] - workers_required[Building.Resident.Peasant] + available_workers[Building.Resident.Peasant];
float peasant_employment_relative = peasant_current == 0 ? 0.0f : peasant_employment / (float)peasant_current;
Unemployment[Building.Resident.Peasant] = peasant_employment_relative > 0.0f ? peasant_employment_relative : 0.0f;
Education[Building.Resident.Peasant] = peasant_current == 0 ? 0.0f : total_education[Building.Resident.Peasant] / peasant_current;
int citizen_current = current_population[Building.Resident.Citizen];
int citizen_max = max_population[Building.Resident.Citizen];
float citizen_happiness = citizen_current > 0 ? happiness[Building.Resident.Citizen] / citizen_current : 0.0f;
Happiness[Building.Resident.Citizen] = citizen_happiness;
int citizen_employment = workers_allocated[Building.Resident.Citizen] - workers_required[Building.Resident.Citizen] + available_workers[Building.Resident.Citizen];
float citizen_employment_relative = citizen_current == 0 ? 0.0f : citizen_employment / (float)citizen_current;
Unemployment[Building.Resident.Citizen] = citizen_employment_relative > 0.0f ? citizen_employment_relative : 0.0f;
Education[Building.Resident.Citizen] = citizen_current == 0 ? 0.0f : total_education[Building.Resident.Citizen] / citizen_current;
int noble_current = current_population[Building.Resident.Noble];
int noble_max = max_population[Building.Resident.Noble];
float noble_happiness = noble_current > 0 ? happiness[Building.Resident.Noble] / noble_current : 0.0f;
Happiness[Building.Resident.Noble] = noble_happiness;
int noble_employment = workers_allocated[Building.Resident.Noble] - workers_required[Building.Resident.Noble] + available_workers[Building.Resident.Noble];
float noble_employment_relative = noble_current == 0 ? 0.0f : noble_employment / (float)noble_current;
Unemployment[Building.Resident.Noble] = noble_employment_relative > 0.0f ? noble_employment_relative : 0.0f;
Education[Building.Resident.Noble] = noble_current == 0 ? 0.0f : total_education[Building.Resident.Noble] / noble_current;
noble_count = noble_current;
TopGUIManager.Instance.Update_City_Info(Name, Cash, Cash_Delta, Mathf.RoundToInt(Usable_Resource_Totals[Resource.Wood]), Mathf.RoundToInt(Usable_Resource_Totals[Resource.Lumber]), Mathf.RoundToInt(Usable_Resource_Totals[Resource.Stone]),
Mathf.RoundToInt(Usable_Resource_Totals[Resource.Bricks]), Mathf.RoundToInt(Usable_Resource_Totals[Resource.Tools]), Mathf.RoundToInt(Usable_Resource_Totals[Resource.Marble]), Mathf.RoundToInt(Usable_Resource_Totals[Resource.Mechanisms]),
Mathf.RoundToInt(Usable_Resource_Totals[Resource.Glass]), peasant_current, peasant_max, peasant_happiness, peasant_employment_relative, peasant_employment, citizen_current, citizen_max, citizen_happiness,
citizen_employment_relative, citizen_employment, noble_current, noble_max, noble_happiness, noble_employment_relative, noble_employment);
DiagnosticsManager.Instance.End(GetType(), "gui");
DiagnosticsManager.Instance.End(GetType(), "total");
}
protected override void OnRecordInsert(string rpTable, long rpRowID)
{
base.OnRecordInsert(rpTable, rpRowID);
Expeditions.AddIfAbsent(LastInsertedRecord.Expedition);
}
