public void SetWorkData(WorkData workData)
{
if (!IsActive)
{
_workData = workData;
}
}
public async Task <IActionResult> Edit(int id, [Bind("WorkDataId,Employer,InitialDate,FinalDate,JobTitle,JobDescription")] WorkData workData)
{
if (id != workData.WorkDataId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
db.Update(workData);
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!WorkDataExists(workData.WorkDataId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(workData));
}
public override void DoWork(WorkData unused)
{
if (MySession.Static.Ready)
{
MyEntityIdentifier.InEntityCreationBlock = true;
MyEntityIdentifier.LazyInitPerThreadStorage(0x800);
int num = 0;
while (true)
{
if (num < this.debrisPieces)
{
MyDebrisBase base2 = this.Context.CreateRandomDebris();
if (base2 != null)
{
float randomFloat = MyUtils.GetRandomFloat(this.minDeviationAngle, this.maxDeviationAngle);
Matrix matrix = Matrix.CreateRotationX(MyUtils.GetRandomFloat(this.minDeviationAngle, this.maxDeviationAngle)) * Matrix.CreateRotationY(randomFloat);
Vector3 vector = Vector3.Transform(this.offsetDirection, matrix);
DebrisData item = new DebrisData {
Object = base2,
StartPos = this.sourceWorldPosition + (vector * MyUtils.GetRandomFloat(this.minSourceDistance, this.maxSourceDistance)),
InitialVelocity = vector * this.initialSpeed
};
this.m_pieces.Add(item);
num++;
continue;
}
}
MyEntityIdentifier.ClearPerThreadEntities();
MyEntityIdentifier.InEntityCreationBlock = false;
return;
}
}
}
protected override bool OnEvaluate(WorkData data)
{
var context = GetContext <ActionParallelContext>(data);
ResetList(context.evaluateStatus, false);
int len = ChildCount;
bool finalResult = false;
for (int i = 0; i < len; i++)
{
var node = GetChild <Action>(i);
bool result = node.Evaluate(data);
if (m_EvaluatePattern == ParallelPattern.AND && !result)
{
finalResult = false;
break;
}
if (result)
{
finalResult = true;
}
context.evaluateStatus[i] = result;
}
return(finalResult);
}
protected override RunningStatus OnUpdate(WorkData data)
{
var context = GetContext <ActionSequenceContext>(data);
var index = context.currentIndex;
RunningStatus status = RunningStatus.Finished;
var node = GetChild <Action>(index);
status = node.Update(data);
//Todo:ErrorCheck
if (!m_ContinueWhenError)
{
context.currentIndex = -1;
return(status);
}
if (status == RunningStatus.Finished)
{
context.currentIndex++;
if (IsIndexVaild(context.currentIndex))
{
status = RunningStatus.Running;
}
else
{
context.currentIndex = -1;
}
}
return(status);
}
protected override RunningStatus OnUpdate(WorkData data)
{
var context = GetContext <ActionSelectorContext>(data);
int lastIndex = context.lastIndex;
int currentIndex = context.currentIndex;
RunningStatus status = RunningStatus.Finished;
if (lastIndex != currentIndex)
{
if (IsIndexVaild(lastIndex))
{
var node = GetChild <Action>(lastIndex);
node.Transition(data);
}
context.lastIndex = context.currentIndex;
}
if (IsIndexVaild(currentIndex))
{
var node = GetChild <Action>(currentIndex);
status = node.Update(data);
if (status == RunningStatus.Finished)
{
context.lastIndex = -1;
}
}
return(status);
}
public void DoWork(WorkData workData = null)
{
T obj = default(T);
while (_notDone)
{
lock (this)
{
_notDone = _enumerator.MoveNext();
if (!_notDone)
{
break;
}
obj = _enumerator.Current;
}
_action(obj);
}
lock (this)
{
if (!_returned)
{
Return();
}
}
}
public void DoWork(WorkData workData = null)
{
try
{
// LOD above is 5 we decrease it by 2 so our LOD now is 3
Min <<= 2;
Max <<= 2;
MyStorageData cache = Cache;
cache.Resize(new Vector3I(8));
for (int x = Min.X; x <= Max.X; x++)
{
for (int y = Min.Y; y <= Max.Y; y++)
{
for (int z = Min.Z; z <= Max.Z; z++)
{
ProcessCell(cache, VoxelMap.Storage, new Vector3I(x, y, z), 0);
}
}
}
Callback();
}
catch (Exception e)
{
Logging.Instance.WriteLine($"{e}");
Callback();
}
}
/// <summary>
/// Get called after <see cref="PlacePad" /> task is completed.
/// </summary>
/// <param name="workData">The work data used in this method.</param>
private void PlacePadCompleted(WorkData workData)
{
using (Log.BeginMethod(nameof(PlacePadCompleted))) {
var data = workData as PlacePadData;
if (data == null)
{
return;
}
switch (data.Result)
{
case PlacePadData.DataResult.Running:
break;
case PlacePadData.DataResult.Success:
IsPadAttached = true;
Deploy();
Log.Debug("Pad placed");
break;
case PlacePadData.DataResult.Failed:
Log.Error("Something went wrong when trying to place pad.");
break;
}
}
}
/// <summary>
/// Get called after <see cref="PlaceSmartHinge" /> task is completed.
/// </summary>
/// <param name="workData">The work data used in this method.</param>
private void PlaceSmartHingeCompleted(WorkData workData)
{
using (Log.BeginMethod(nameof(PlaceSmartHingeCompleted))) {
var data = workData as PlaceSmartHingeData;
if (data?.Head == null)
{
return;
}
switch (data.Result)
{
case PlaceSmartHingeData.DataResult.Running:
break;
case PlaceSmartHingeData.DataResult.Success:
IsHingeAttached = true;
Log.Debug("Hinge placed");
break;
case PlaceSmartHingeData.DataResult.Failed:
Log.Error("Something went wrong when trying to place hinge.");
break;
}
}
}
protected sealed override RunningStatus OnUpdate(WorkData data)
{
var runningStatus = RunningStatus.Finished;
var context = GetContext <ActionLeafContext>(data);
if (context.status == ACTION_READY)
{
OnEnter(data);
context.status = ACTION_RUNNING;
context.needExit = true;
}
if (context.status == ACTION_RUNNING)
{
runningStatus = OnExecute(data);
if (runningStatus == RunningStatus.Finished)
{
context.status = ACTION_FINISHED;
}
}
if (context.status == ACTION_FINISHED)
{
if (context.needExit)
{
OnExit(data, runningStatus);
}
context.needExit = false;
context.status = ACTION_READY;
}
return(runningStatus);
}
public static void DoWork(WorkData wd)
{
var data = (UpdateWorkData)wd;
if (data == null)
{
return;
}
foreach (var hash in tanksUpdated.Keys)
{
try
{
if ((hash & int.MaxValue) % data.totalBuckets != data.bucket)
{
continue;
}
tanksUpdated.TryRemove(hash, out var tuple);
if (tuple == null || tuple.Item1 == null)
{
continue;
}
Func <MyGasTank, Action <double> > fn = (MyGasTank x) => (Action <double>)GasTankPatch.cb.CreateDelegate(typeof(Action <double>), x);
MyMultiplayer.RaiseEvent <MyGasTank, double>(tuple.Item1, fn, tuple.Item2);
}
catch (Exception e)
{
Plugin.Error("Gas tanks processing error", e);
}
}
}
public void DoWork(WorkData workData = null)
{
while (_index < _max)
{
int exec;
lock (this)
{
exec = _index;
_index += _stride;
}
if (exec < _max)
{
_action(exec);
}
}
lock (this)
{
if (!_returned)
{
Return();
}
}
}
public (float, float[]) CalculateAppeal(WorkData work)
{
var resIdol = new float[Capacity];
for (int i = 0; i < Capacity; i++)
{
if (IdolIndices[i] != -1)
{
var idol = IngameManager.Instance.Data.Idols[IdolIndices[i]];
if (work.CheckAbility[0])
{
resIdol[i] += idol.Vocal * 10;
}
if (work.CheckAbility[1])
{
resIdol[i] += idol.Dance * 10;
}
if (work.CheckAbility[2])
{
resIdol[i] += idol.Visual * 10;
}
if (work.CheckAbility[3])
{
resIdol[i] += idol.Variety * 10;
}
}
}
var finalRes = ApplyPersonality(ref resIdol);
return(finalRes, resIdol);
}
public static void Main(string[] args)
{
ReadFile reader = new ReadFile();
Scene scene;
if (args.Length != 1)
{
Console.Error.WriteLine("Le lecteur de fichier de scène attend un fichier exactement !!");
System.Environment.Exit(1);
}
try
{
int nbThread = Environment.ProcessorCount;
//ManualResetEvent[] doneEvents = new ManualResetEvent[nbThread];
Thread[] jobs = new Thread[nbThread];
scene = reader.Analyze(args[0]);
/*
* ///Application des transformations aux triangles
* if (scene.Transformation.Count > 0)
* {
* for (int i = 0; i < scene.Entite.Count; i++)
* scene.Entite[i] = scene.Entite[i].getTransform(scene.Transformation[0]);
* }
*/
//Initialisation du lanceur et génération de l'image.
Lanceur lanceur = new Lanceur(scene);
for (int i = 0; i < nbThread; i++)
{
WorkData data = new WorkData(i, nbThread);
jobs[i] = new Thread(() => lanceur.GenerateImage(data));
jobs[i].Start();
}
for (int i = 0; i < nbThread; i++)
{
jobs[i].Join();
}
}
catch (IOException e)
{
Console.WriteLine("Le fichier de sortie n'à pas pu être enregistré !!!");
Console.Error.WriteLine(e.Message);
System.Environment.Exit(1);
}
catch (ArgumentException f)
{
Console.WriteLine(f.Message);
System.Environment.Exit(1);
}
catch (FormatException)
{
Console.WriteLine("Un ou plusieurs arguments ne sont pas des nombres !!!");
System.Environment.Exit(1);
}
}
private void AddTimeWindowConstrains(WorkData data, RoutingIndexManager manager, RoutingModel routing)
{
// Create and register a transit callback
int transitCallbackIndex = routing.RegisterTransitCallback(
(long fromIndex, long toIndex) =>
{
int fromNode = manager.IndexToNode(fromIndex);
int toNode = manager.IndexToNode(toIndex);
return(data.DurationMatrix[fromNode, toNode] + data.ServiceTimes[fromNode]);
});
routing.AddDimension(transitCallbackIndex, 120, MAX_VEHICLE_ROUTING_TIME, false, "Time");
// Add time window constraints for each location except depot
RoutingDimension timeDimension = routing.GetDimensionOrDie("Time");
for (int i = 1; i < data.TimeWindows.GetLength(0); ++i)
{
long index = manager.NodeToIndex(i);
timeDimension.CumulVar(index).SetRange(data.TimeWindows[i][0], data.TimeWindows[i][1]);
}
// Add time window constraints for each vehicle start node
for (int i = 0; i < data.VehiclesAmount; ++i)
{
long index = routing.Start(i);
timeDimension.CumulVar(index).SetRange(data.TimeWindows[0][0], data.TimeWindows[0][1]);
routing.AddVariableMinimizedByFinalizer(timeDimension.CumulVar(routing.Start(i)));
routing.AddVariableMinimizedByFinalizer(timeDimension.CumulVar(routing.End(i)));
}
}
private void AddCapacityConstrains(WorkData data, RoutingIndexManager manager, RoutingModel routing)
{
// Create and register a transit callback
int transitCallbackIndex = routing.RegisterTransitCallback(
(long fromIndex, long toIndex) =>
{
// Convert from routing variable Index to distance matrix NodeIndex
int fromNode = manager.IndexToNode(fromIndex);
int toNode = manager.IndexToNode(toIndex);
return(data.DistanceMatrix[fromNode, toNode]);
});
// Define cost of each arc.
routing.SetArcCostEvaluatorOfAllVehicles(transitCallbackIndex);
// Add Capacity constraint
int demandCallbackIndex = routing.RegisterUnaryTransitCallback(
(long fromIndex) =>
{
int fromNode = manager.IndexToNode(fromIndex);
return(data.Demands[fromNode]);
});
// AddDimensionWithVehicleCapacity method, which takes a vector of capacities
routing.AddDimensionWithVehicleCapacity(demandCallbackIndex, 0, data.VehicleCapacities, true, "Capacity");
}
public void FlushCaches(WorkData data)
{
StorageData data1 = (StorageData)data;
data1.Storage.CleanCachedChunks();
data1.Scheduled = false;
Interlocked.Decrement(ref this.m_scheduledCount);
}
private void AddPenaltiesAndDroppingVisits(WorkData data, RoutingIndexManager manager, RoutingModel routing)
{
// Allow to drop nodes.
for (int i = 1; i < data.DistanceMatrix.GetLength(0); ++i)
{
routing.AddDisjunction(new long[] { manager.NodeToIndex(i) }, MAX_VEHICLE_PENALTY);
}
}
public void SetWorkData(WorkData workData)
{
if (!IsActive)
{
_workData = workData;
_scale = _workData.EntityScale;
}
}
public void WritePending(WorkData data)
{
StorageData data1 = (StorageData)data;
data1.Storage.WritePending(false);
data1.Scheduled = false;
Interlocked.Decrement(ref this.m_scheduledCount);
}
/// <summary>
/// Get called after <see cref="PlaceSmartHinge" /> task is completed.
/// </summary>
/// <param name="workData">The work data used in this method.</param>
private void PlaceSmartHingeCompleted(WorkData workData)
{
using (Mod.PROFILE ? Profiler.Measure(nameof(SmartRotorBase), nameof(PlaceSmartHingeCompleted)) : null) {
using (Log.BeginMethod(nameof(PlaceSmartHingeCompleted))) {
Log.Debug("Hinge placed");
}
}
}
/// <summary>
/// 생성자 컨트롤러 생성 시 보드 폼, 일정 폼을 컨트롤러와 연결
/// </summary>
/// <param name="_boardForm"></param>
/// <param name="_workForm"></param>
public BoardFormController(BoardForm _boardForm, WorkForm _workForm)
{
boardForm = _boardForm;
workForm = _workForm;
BoardData = new BoardData("New Board");
CurrentWork = new WorkData();
isLabel = false;
}
public void SetWorkData(WorkData workData)
{
if (!IsActive)
{
_workData = workData;
_scaledSize = _workData.BaseSize;
}
}
public void SetWorkData(WorkData workData)
{
if (!IsActive)
{
_workData = workData;
_rotationPlane = new Plane(_workData.Axis, _workData.RotationPlanePos);
}
}
public unsafe void DoWork(WorkData workData = null)
{
try
{
//MyEntities.EntityCloseLock.AcquireShared();
if (m_renderObject == null)
{
return;
}
if (m_renderObject is MyRenderVoxelCell)
{
}
Vector3 directionToSunNormalized = -MyRender.Sun.Direction;
VisibleFromSun = false;
var line2 = new LineD(m_renderObject.WorldVolume.Center, m_renderObject.WorldVolume.Center + directionToSunNormalized * MyShadowRenderer.SHADOW_MAX_OFFSET * 0.5f);
var result2 = MyRender.GetAnyIntersectionWithLine(MyRender.ShadowPrunning, ref line2, m_renderObject, null, m_overlapList);
VisibleFromSun |= (result2 == null); //if nothing hit, its visible from sun
if (m_renderObject.FastCastShadowResolve)
{
return;
}
Vector3D *corners = stackalloc Vector3D[8];
m_renderObject.GetCorners(corners);
for (int i = 0; i < 8; i++)
{
LineD line = new LineD(corners[i], corners[i] + directionToSunNormalized * MyShadowRenderer.SHADOW_MAX_OFFSET * 0.5f);
var result = MyRender.GetAnyIntersectionWithLine(MyRender.ShadowPrunning, ref line, m_renderObject, null, m_overlapList);
VisibleFromSun |= (result == null);
if (VisibleFromSun)
{
break;
}
}
if (!VisibleFromSun)
{
}
}
finally
{ /*
* if (m_renderObject != null)
* {
* m_renderObject.OnClose -= m_entity_OnMarkForClose;
* }
*/
// MyEntities.EntityCloseLock.ReleaseShared();
}
}
public void WritePending(WorkData data)
{
var storageData = (StorageData)data;
storageData.Storage.WritePending();
storageData.Scheduled = false;
Interlocked.Decrement(ref m_scheduledCount);
}
public void FlushCaches(WorkData data)
{
var storageData = (StorageData)data;
storageData.Storage.CleanCachedChunks();
storageData.Scheduled = false;
Interlocked.Decrement(ref m_scheduledCount);
}
public void SetWorkData(WorkData workData)
{
if (!IsActive)
{
_workData = workData;
_scale = 1.0f;
_scaleDragAxis = ((workData.CameraRight + workData.CameraUp) * 0.5f).normalized;
}
}
private void OnProfilerRequestComplete(WorkData data)
{
ProfilerData data2 = data as ProfilerData;
base.SyncLayer.TransportLayer.SendFlush(data2.Sender.Value);
Vector3D?position = null;
MyMultiplayer.RaiseStaticEvent <byte[]>(s => new Action <byte[]>(MyMultiplayerClientBase.ReceiveProfiler), data2.Buffer, new EndpointId(data2.Sender.Value), position);
}
public static void Select(string SQL, WorkData WD)
{
FbCommand cmd = new FbCommand(SQL);
using (cmd.Connection = new FbConnection(ConnectionString))
{
cmd.Connection.Open();
FbDataReader dr = cmd.ExecuteReader();
while (dr.Read())
{
WD(dr);
}
}
}
void Awake()
{
m_renderer = GetComponent<BatchRenderer>();
m_renderer.m_flush_on_LateUpdate = false;
m_entities = new BulletEntity[m_max_entities];
m_entities_to_add = new BulletEntity[m_max_entities];
m_num_tasks = m_max_entities / m_entities_par_task + (m_max_entities % m_entities_par_task != 0 ? 1 : 0);
m_work_data = new WorkData();
m_work_data.targets = new HitTarget[128];
m_task_work_data = new TaskWorkData[m_num_tasks];
}
public static int Pack(WorkData Data)
{
string mKernel, mRamdisk, mSecondStage, mtkKernelHdr, mtkRamdiskHdr;
mKernel = mRamdisk = mSecondStage = mtkKernelHdr = mtkRamdiskHdr = string.Empty;
ImgHeader hdr;
//Для запаковки папки обязательно нужен исходный заголовок
if (Data.Mode == WorkMode.Pack)
{
string mHeader = Path.Combine(Data.pack_dir, "image.hdr");
mKernel = Path.Combine(Data.pack_dir, "zImage");
mRamdisk = Path.Combine(Data.pack_dir, "ram_disk.gz");
mSecondStage = Path.Combine(Data.pack_dir, "second.bin");
mtkKernelHdr = mKernel + ".mtkhdr";
mtkRamdiskHdr = mRamdisk + ".mtkhdr";
Console.WriteLine("Packing image...");
Console.WriteLine("Source folder: {0}", Data.pack_dir);
Console.WriteLine("Destination file: {0}", Data.output_path);
Console.Write("Looking for template header 'image.hdr'... ");
if (File.Exists(mHeader))
{
ConsoleEx.WriteLine(ConsoleColor.Green, "OK");
hdr = ImgHeader.FromBytes(File.ReadAllBytes(mHeader));
}
else
{
ConsoleEx.WriteLine(ConsoleColor.Red, "Error: file not found");
return 1;
}
}
else
hdr = new ImgHeader();
//Обновляем данные в заголовке согласно новым входным
UpdateHeader(ref hdr, Data);
Console.Write("Looking for source images... ");
//Пытаемся загрузить образы либо из файла пакета, либо из входного. Приоритет на входной.
byte[] bKernel = LoadImage(mKernel, Data.kernel_data);
byte[] bRamdisk = LoadImage(mRamdisk, Data.ramdisk_data);
byte[] bSecondStage = LoadImage(mSecondStage, Data.second_data);
//Если что-то не загрузилось ни из одного источника - возвращаеам ошибку
if (bKernel == null || bRamdisk == null)
{
ConsoleEx.WriteLine(ConsoleColor.Red, "FAILED");
return -2; // NO SOURCE IMAGES FOUND
}
ConsoleEx.WriteLine(ConsoleColor.Green, "OK.");
//Проверяем, есть ли хоть один источник заголовка МТК.
//Если хоть что-то есть, то считаем что наш образ полностью для МТК-устройства
//Также если установлен флаг mtk_force, то необходимо создавать заголовки вручную
if (File.Exists(mtkKernelHdr) || File.Exists(mtkRamdiskHdr)
|| Data.mtk_kernel_hdr_data != null || Data.mtk_ramdisk_hdr_data != null
|| Data.mtk_force)
{
ConsoleEx.WriteLine(ConsoleColor.White, "Image will be in MTK format!");
byte[] bMtkKernelHdr = LoadImage(mtkKernelHdr, Data.mtk_kernel_hdr_data);
byte[] bMtkRamdiskHdr = LoadImage(mtkRamdiskHdr, Data.mtk_ramdisk_hdr_data);
if (bMtkKernelHdr == null)
ConsoleEx.WriteLine(ConsoleColor.Yellow, "Template of MTK kernel header not found. Will be created a fresh one.");
if (bMtkRamdiskHdr == null)
ConsoleEx.WriteLine(ConsoleColor.Yellow, "Template of MTK ramdisk header not found. Will be created a fresh one.");
//если что-то не загрузили, то необходимо создать новый экземпляр
mtkSectionHeader smtkKernelHdr = (bMtkKernelHdr != null)
? mtkSectionHeader.FromBytes(bMtkKernelHdr)
: new mtkSectionHeader("KERNEL");
mtkSectionHeader smtkRamdiskHdr = (bMtkRamdiskHdr != null)
? mtkSectionHeader.FromBytes(bMtkRamdiskHdr)
: new mtkSectionHeader("ROOTFS");
//Если установлено имя секции рутфс, меняем
if (Data.mtk_ramdisk_name != null)
{
Console.WriteLine("Defining name of ramdisk as '{0}'", Data.mtk_ramdisk_name);
smtkRamdiskHdr.SetName(Data.mtk_ramdisk_name);
}
Console.WriteLine("Generating MTK sections...");
//создаем новые МТК-секции
bKernel = mtkSectionWriter.GetBytes(smtkKernelHdr, bKernel);
bRamdisk = mtkSectionWriter.GetBytes(smtkRamdiskHdr, bRamdisk);
}
//Показываем таблицу шаблона
Console.WriteLine("Creating image... ");
hdr.kernel_size = (uint)bKernel.Length;
hdr.ramdisk_size = (uint)bRamdisk.Length;
hdr.second_size = bSecondStage == null ? (uint)0 : (uint)bSecondStage.Length;
hdr.PrintInfo();
//Записываем итоговый
long sz = 0;
if (ImgWriter.Write(hdr, bKernel, bRamdisk, bSecondStage, Data.output_path, ref sz))
{
Console.WriteLine();
ConsoleEx.Write(ConsoleColor.Green, "Done!");
if (sz > 0x600000)
ConsoleEx.WriteLine(ConsoleColor.Yellow, " But be careful! Size of compiled image is more than 6MB!", sz);
return 0; //OK
}
ConsoleEx.WriteLine(ConsoleColor.Red, "Oops. Something is wrong.");
return -1; //WRITING FAILED
}
public static void UpdateHeader(ref ImgHeader hdr, WorkData Data)
{
uint OffsetBase = hdr.GetConjecturalBase();
if (Data.base_offset != null)
{
hdr.SetBase(OffsetBase, Data.base_offset.Value);
OffsetBase = Data.base_offset.Value;
}
if (Data.kernel_offset != null)
hdr.SetAddress(ref hdr.kernel_addr, OffsetBase, Data.kernel_offset.Value);
if (Data.ramdisk_offset != null)
hdr.SetAddress(ref hdr.ramdisk_addr, OffsetBase, Data.ramdisk_offset.Value);
if (Data.second_offset != null)
hdr.SetAddress(ref hdr.second_addr, OffsetBase, Data.second_offset.Value);
if (Data.tags_offset != null)
hdr.SetAddress(ref hdr.tags_addr, OffsetBase, Data.tags_offset.Value);
if (Data.pagesize != null)
hdr.page_size = Data.pagesize.Value;
if (Data.cmdline != null)
hdr.SetCmdLine(Data.cmdline);
if (Data.board != null)
hdr.SetName(Data.board);
}
