// private Dictionary<string,bool[]> gadgetPrefabs = new Dictionary<string, bool[]>(); //kaa sauc gadgeta prefabu | kaadaas telpaas tas var atrasties
public void Awake()
{
levelscript = GameObject.Find("Level").GetComponent<Level>(); //no-bullshit singleton
gResScript = GameObject.Find("Level").GetComponent<GlobalResources>(); //no-bullshit singleton
workManagerScript = GameObject.Find("Level").GetComponent<WorkManager>();
camerascript = GameObject.Find("Camera").GetComponent<Camctrl>(); //no-bullshit singleton
Init();
}
public async Task <PreRouteDto> Insert(PreRouteDto input)
{
var entity = ObjectMapper.Map <PreRoute>(input);
entity.DepotId = WorkManager.GetWorkerDepotId(GetCurrentUserWorkerIdAsync().Result);
await _preRouteRepository.InsertAsync(entity);
CurrentUnitOfWork.SaveChanges();
return(ObjectMapper.Map <PreRouteDto>(entity));
}
private void DrawBuildProgress()
{
GUI.skin = ResourceManager.SelectBoxSkin;
Rect selectBox = WorkManager.CalculateSelectionBox(selectionBounds, playingArea);
GUI.BeginGroup(playingArea);
CalculateCurrentHealth(0.5f, 0.99f);
DrawHealthBar(selectBox, "Building ...");
GUI.EndGroup();
}
/// <summary>
/// Execute query data
/// </summary>
/// <param name="query">Query object</param>
/// <returns>Return data</returns>
protected override async Task <TEntity> ExecuteGetAsync(IQuery query)
{
ICommand cmd = RdbCommand.CreateNewCommand <TEntity>(OperateType.Query);
SetCommand(cmd, null);
cmd.Query = query;
TEntity data = await WorkManager.QuerySingleAsync <TEntity>(cmd).ConfigureAwait(false);
return(data);
}
/// <summary>
/// Execute query data paging
/// </summary>
/// <param name="query">Query object</param>
/// <returns>Return data paging</returns>
protected override async Task <PagingInfo <TEntity> > ExecuteGetPagingAsync(IQuery query)
{
ICommand cmd = RdbCommand.CreateNewCommand <TEntity>(OperateType.Query);
SetCommand(cmd, null);
cmd.Query = query;
var dataPaging = await WorkManager.QueryPagingAsync <TEntity>(cmd).ConfigureAwait(false);
return(dataPaging);
}
/// <summary>
/// Execute exists
/// </summary>
/// <param name="query">Query object</param>
/// <returns>Return whether data is exist</returns>
protected override async Task <bool> ExecuteExistAsync(IQuery query)
{
var cmd = RdbCommand.CreateNewCommand <TEntity>(OperateType.Exist);
SetCommand(cmd, null);
cmd.MustReturnValueOnSuccess = true;
cmd.Query = query;
cmd.CommandResultType = ExecuteCommandResult.ExecuteScalar;
return(await WorkManager.QueryAsync(cmd).ConfigureAwait(false));
}
private void CompleteBuilding()
{
currentProject.FinishConstruction();
faction.UnClaim(currentProject, this);
faction.UnClaim(gatherTarget, this);
currentProject = gatherTarget = null;
currentBuild = currentGather = 0.0f;
building = false;
resourcesSpent = WorkManager.InitResourceList();
}
private void Job3(WorkManager workManager)
{
for (uint i = 0; i < 10; i++)
{
workManager.PauseCycle();
workManager.ChangeProgress(i + 1, 10);
Thread.Sleep(250);
}
Thread.Sleep(2000);
}
public void SevenIsPrimeTest()
{
WorkManager testInstance = new WorkManager();
testInstance.Start();
PrimeChecker actual = testInstance.ProcessPrime(7);
Assert.AreEqual(true, actual.IsPrime);
}
public void SixIsPerfectTest()
{
WorkManager testInstance = new WorkManager();
testInstance.Start();
PerfectChecker actual = testInstance.ProcessPerfect(6);
Assert.AreEqual(true, actual.IsPerfect);
}
private static void StartThread()
{
if (cmdHandlerThread == null)
{
// Start the thread that will be doing the work
cmdHandlerThread
= WorkManager.StartThread(
CmdHandlerThreadLoop, "AsyncLSLCmdHandlerThread", ThreadPriority.Normal, true, true);
}
}
public void simpleWrk()
{
var simpleWorkerRequest = new OneTimeWorkRequest.Builder(typeof(SimpleWorker))
.AddTag(SimpleWorker.TAG)
.Build();
WorkManager.GetInstance(context).BeginUniqueWork(
SimpleWorker.TAG, ExistingWorkPolicy.Keep, simpleWorkerRequest)
.Enqueue();
}
private void DrawSelection()
{
GUI.skin = ResourceManager.SelectBoxSkin;
Rect selectBox = WorkManager.CalculateSelectionBox(selectionBounds, playingArea);
//Draw the selection box around the currently selected object, within the bounds of the playing area
GUI.BeginGroup(playingArea);
DrawSelectionBox(selectBox);
GUI.EndGroup();
}
public override Vector3 GetFlagPosition()
{
Vector3 res = ResourceManager.InvalidPosition;
if (nav.enabled && !WorkManager.VectorEquals(nav.destination, transform.position, 1))
{
res = nav.destination;
}
return(res);
}
public async Task <List <RouteDto> > GetAuxRoutesAsync(DateTime carryoutDate, int workplaceId, string sorting)
{
var depots = WorkManager.GetShareDepots(workplaceId);
var query = _routeRepository.GetAllIncluding(x => x.RouteType, x => x.Vehicle, x => x.AltVehicle, x => x.CreateWorker);
query = query.Where(x => x.CarryoutDate == carryoutDate && depots.Contains(x.DepotId) && _activeStatus.Contains(x.Status)).OrderBy(sorting);
var entities = await AsyncQueryableExecuter.ToListAsync(query);
return(ObjectMapper.Map <List <RouteDto> >(entities));
}
public async Task <List <RouteDto> > GetRoutesAsync(DateTime carryoutDate, string sorting)
{
int depotId = WorkManager.GetWorkerDepotId(await GetCurrentUserWorkerIdAsync());
var query = _routeRepository.GetAllIncluding(x => x.RouteType, x => x.Vehicle, x => x.AltVehicle, x => x.CreateWorker);
query = query.Where(x => x.DepotId == depotId && x.CarryoutDate == carryoutDate).OrderBy(sorting);
var entities = await AsyncQueryableExecuter.ToListAsync(query);
return(ObjectMapper.Map <List <RouteDto> >(entities));
}
public MainWindow()
{
InitializeComponent();
// Create ReflectInsight Object for Logging.
ri = new ReflectInsight("SpeechSynthesizerService.TestClient");
// Initialize the WorkManager
wManager = new WorkManager();
}
/// <summary>
/// Aggregate function query
/// </summary>
/// <typeparam name="TValue">Value type</typeparam>
/// <param name="query">Query object</param>
/// <returns>Return the value</returns>
async Task <TValue> AggregateFunctionAsync <TValue>(OperateType funcType, IQuery query)
{
ICommand cmd = RdbCommand.CreateNewCommand <TEntity>(funcType);
SetCommand(cmd, null);
cmd.Query = query;
TValue data = await WorkManager.AggregateValueAsync <TValue>(cmd).ConfigureAwait(false);
return(data);
}
/*** Private Methods ***/
private void DrawBuildProgress()
{
GUI.skin = ResourceManager.SelectBoxSkin;
Rect selectBox = WorkManager.CalculateSelectionBox(selectionBounds, playingArea);
//Draw the selection box around the currently selected object, within the bounds of the main draw area
GUI.BeginGroup(playingArea);
CalculateCurrentHealth(0.5f, 0.99f);
DrawHealthBar(selectBox, "Building ...");
}
/// <summary>
/// Execute query data list
/// </summary>
/// <param name="query">Query object</param>
/// <returns>Return data list</returns>
protected override async Task <List <TEntity> > ExecuteGetListAsync(IQuery query)
{
ICommand cmd = RdbCommand.CreateNewCommand <TEntity>(OperateType.Query);
SetCommand(cmd, null);
cmd.Query = query;
var dataList = (await WorkManager.QueryAsync <TEntity>(cmd).ConfigureAwait(false)).ToList();
return(dataList);
}
private void WorldObjectMouseClick(WorldObject objectHandler, GameObject hitObject, Vector3 hitPoint)
{
//only handle input if currently selected
if (objectHandler.IsSelected() && !WorkManager.ObjectIsGround(hitObject))
{
if (!hitObject.transform.parent)
{
return;
}
WorldObject worldObject = hitObject.transform.parent.GetComponent <WorldObject>();
//clicked on another selectable object
if (worldObject)
{
Player owner = hitObject.transform.root.GetComponent <Player>();
if (owner)
{ //the object is controlled by a player
// get owner of the object handler
Player objectHandlerOwner = objectHandler.GetComponentInParent <Player>();
if (objectHandlerOwner && player && objectHandlerOwner.username == player.username && player.human)
{ //this object is controlled by a human player
var handlerStateController = objectHandler.GetStateController();
//start attack if object is not owned by the same player and this object can attack, else select
if (handlerStateController && player.username != owner.username && objectHandler.CanAttack())
{
InputToCommandManager.ToChaseState(targetManager, handlerStateController, worldObject);
}
else
{
IssueMoveOrderToSelectedUnits(hitObject, hitPoint);
}
}
}
else if (objectHandler.CanAttack())
{
if (!hitObject.transform.parent)
{
return;
}
Unit unit = hitObject.transform.parent.GetComponent <Unit>();
Building building = hitObject.transform.parent.GetComponent <Building>();
BossPart bossPart = hitObject.transform.parent.GetComponent <BossPart>();
var handlerStateController = objectHandler.GetStateController();
if ((unit || building || bossPart) && handlerStateController)
{
InputToCommandManager.ToChaseState(targetManager, handlerStateController, worldObject);
}
}
// else ChangeSelection(objectHandler, worldObject);
}
}
}
// --------------- Left Mouse! ----------------
private void LeftMouseClick()
{
if (player.hud.MouseInBounds())
{
if (player.IsFindingBuildingLocation())
{
if (player.CanPlaceBuilding())
{
player.StartConstruction();
}
}
else
{
if (player.hud.MouseInBounds())
{
GameObject hitObject = WorkManager.FindHitObject(Input.mousePosition);
Vector3 hitPoint = WorkManager.FindHitPoint(Input.mousePosition);
if (hitObject)
{
if (player.SelectedObject)
{
if (hitObject.name != "WorldMap")
{
WorldObject worldObject = hitObject.transform.parent.GetComponent <WorldObject>();
if (worldObject)
{
player.SelectedObject.SetSelection(false, player.hud.GetPlayingArea());
player.SelectedObject = null;
//we already know the player has no selected object
player.SelectedObject = worldObject;
worldObject.SetSelection(true, player.hud.GetPlayingArea());
}
}
else
{
player.SelectedObject.SetSelection(false, player.hud.GetPlayingArea());
player.SelectedObject = null;
}
}
else if (hitObject.name != "WorldMap")
{
WorldObject worldObject = hitObject.transform.parent.GetComponent <WorldObject>();
if (worldObject)
{
//we already know the player has no selected object
player.SelectedObject = worldObject;
worldObject.SetSelection(true, player.hud.GetPlayingArea());
}
}
}
}
}
}
}
public override void RunEventScript()
{
enemyUnits = WorkManager.GetAllyObjects(
WorkManager.FindNearbyUnits(arenaCenter.transform.position, arenaRadius).Cast <WorldObject>().ToList(),
enemyPlayer
)
.Where(obj => obj is Unit)
.ToList();
inProgress = true;
}
public void FindBuildingLocation()
{
Vector3 newLocation = WorkManager.FindHitPoint();
if (newLocation != ResourceManager.InvalidPosition)
{
buildSpace.position = new Vector3(Mathf.Round(newLocation.x),
Mathf.Round(newLocation.y),
Mathf.Round(newLocation.z));
}
}
bool TargetInFrontOfWeapon()
{
Vector3 direction = (target.transform.position - transform.position);
direction.y = 0;
direction.Normalize();
bool res = this is Building || WorkManager.VectorEquals(direction, transform.forward, 0.02f) || direction == Vector3.zero;
return(res);
}
public override void LookForTarget()
{
if (mySpawnerWorldObject && mySpawnerWorldObject.paramManager.PlayerOwned)
{
targetCollider = WorkManager.DetermineNearestEnemySpawnTargetColliderInRange(transform.position, paramManager.AggroRange);
}
else if (mySpawnerWorldObject && !mySpawnerWorldObject.paramManager.PlayerOwned)
{
targetCollider = WorkManager.DetermineNearestEnemySpawnTargetColliderInRange(transform.position, paramManager.AggroRange);
}
}
private bool TargetInFrontOfWeapon(WorldObject target)
{
if (WorkManager.IsObjectFacingTarget(this, target))
{
return(true);
}
else
{
return(false);
}
}
public AsyncCommandManager(IScriptEngine _ScriptEngine)
{
m_ScriptEngine = _ScriptEngine;
// If there is more than one scene in the simulator or multiple script engines are used on the same region
// then more than one thread could arrive at this block of code simultaneously. However, it cannot be
// executed concurrently both because concurrent list operations are not thread-safe and because of other
// race conditions such as the later check of cmdHandlerThread == null.
lock (staticLock)
{
if (m_ScriptEngines.Count == 0)
{
ReadConfig();
}
if (!m_ScriptEngines.Contains(m_ScriptEngine))
{
m_ScriptEngines.Add(m_ScriptEngine);
}
// Create instances of all plugins
if (!m_Dataserver.ContainsKey(m_ScriptEngine))
{
m_Dataserver[m_ScriptEngine] = new Dataserver(this);
}
if (!m_Timer.ContainsKey(m_ScriptEngine))
{
m_Timer[m_ScriptEngine] = new Timer(this);
}
if (!m_HttpRequest.ContainsKey(m_ScriptEngine))
{
m_HttpRequest[m_ScriptEngine] = new HttpRequest(this);
}
if (!m_Listener.ContainsKey(m_ScriptEngine))
{
m_Listener[m_ScriptEngine] = new Listener(this);
}
if (!m_SensorRepeat.ContainsKey(m_ScriptEngine))
{
m_SensorRepeat[m_ScriptEngine] = new SensorRepeat(this);
}
if (!m_XmlRequest.ContainsKey(m_ScriptEngine))
{
m_XmlRequest[m_ScriptEngine] = new XmlRequest(this);
}
numInstances++;
if (cmdHandlerThread == null)
{
cmdHandlerThread = WorkManager.StartThread(
CmdHandlerThreadLoop, "AsyncLSLCmdHandlerThread");
}
}
}
/// <summary>
/// Save by second type datas
/// </summary>
/// <param name="datas">Datas</param>
/// <param name="activationOption">Activation option</param>
public sealed override void SaveBySecond(IEnumerable <TSecondModel> datas, ActivationOption activationOption = null)
{
var saveRecords = ExecuteSaveBySecond(datas, activationOption);
if (saveRecords.IsNullOrEmpty())
{
return;
}
RepositoryEventBus.PublishSave(GetType(), datas, activationOption);
WorkManager.RegisterActivationRecord(saveRecords);
}
/// <summary>
/// Remove
/// </summary>
/// <param name="datas">Datas</param>
/// <param name="activationOption">Activation option</param>
public sealed override void Remove(IEnumerable <Tuple <TFirstModel, TSecondModel> > datas, ActivationOption activationOption = null)
{
var records = ExecuteRemove(datas, activationOption);
if (records.IsNullOrEmpty())
{
return;
}
RepositoryEventBus.PublishRemove(GetType(), datas, activationOption);
WorkManager.RegisterActivationRecord(records);
}
public void StartKeepWork()
{
WorkManager.GetInstance(this).CancelAllWorkByTag(TAG_KEEP_WORK);
Log.Debug(TAG, "keep-> dowork startKeepWork");
OneTimeWorkRequest oneTimeWorkRequest = new OneTimeWorkRequest.Builder(typeof(KeepLiveWork))
.SetBackoffCriteria(AndroidX.Work.BackoffPolicy.Linear, 5, Java.Util.Concurrent.TimeUnit.Seconds)
.AddTag(TAG_KEEP_WORK)
.Build();
WorkManager.GetInstance(this).Enqueue(oneTimeWorkRequest);
}
protected virtual void Awake()
{
selectionBounds = ResourceManager.InvalidBounds;
CalculateBounds();
resources = WorkManager.InitResourceList();
resourceLimits = WorkManager.InitResourceList();
resourceCosts = WorkManager.InitResourceList();
AddStartResourceLimits();
SetResourceCosts();
}
protected virtual void Init()
{
canvas = Canvas.FindObjectOfType<Canvas>();
canvasManager = canvas.GetComponent<CanvasManager>();
//WorldInterface.CreateGameWorld(worldSize);
worldInterface = WorldInterface.CreateWorldInterface(worldSize);
pointObjectManager = PointObjectManager.CreatePointObjectManager();
actionManager = gameObject.AddComponent<ActionManager>();
workManager = gameObject.AddComponent<WorkManager>();
pathFinder = new Pathfinder();
if (buildStartArea)
{
BuildStartArea();
}
}
public WorkManagerConfigurator(IUpdateState workManager, ProtoregSerializer protoregSerializer)
{
IMessageSerializer massTransitSerializer = new MassTransitSerializer(protoregSerializer);
mngr = new WorkManager(workManager, new RabbitMqManagerStateRepository(protoregSerializer));
serviceBusManager = ServiceBusFactory.New(sbc =>
{
sbc.ReceiveFrom("rabbitmq://localhost/AsyncWork-WorkDone");
sbc.UseRabbitMq();
sbc.SetPurgeOnStartup(false);
sbc.SetDefaultSerializer(massTransitSerializer);
sbc.SetConcurrentConsumerLimit(1);
sbc.Subscribe(subs =>
{
subs.Instance(mngr);
});
});
}
public EventHubListenerDataHandler(WorkManager<RoutetoActorWorkItemHandler, RouteToActorWorkItem> WorkManager)
{
this.workManager = WorkManager;
}
protected override async Task RunAsync(CancellationToken cancellationToken)
{
this.TraceWriter.EnablePrefix = true;
#if _WAIT_FOR_DEBUGGER
while (!Debugger.IsAttached)
await Task.Delay(5000);
#endif
// Create a work manager that is expected to receive a work item of type RouteToActor
// The work manager will queue them (according to RouteToActor.Queue Name property). Then for each work
//item de-queued it will use RouteToActorWorkItemHandler type to process the work item
this.WorkManager = new WorkManager<RoutetoActorWorkItemHandler, RouteToActorWorkItem>(this.StateManager, this.TraceWriter);
// work manager will creates a new (RoutetoActorWorkItemHandler)
// per queue. our work item handling is basically forwarding event hub message to the Actor.
// since each Actor will have it is own queue (and a handler). each handler
// can cache a reference to the actor proxy instead of caching them at a higher level
this.WorkManager.WorkItemHandlerMode = WorkItemHandlerMode.PerQueue;
// maximum # of worker loops (loops that de-queue from reliable queue)
this.WorkManager.MaxNumOfWorkers = WorkManager<RoutetoActorWorkItemHandler, RouteToActorWorkItem>.s_Max_Num_OfWorker;
this.WorkManager.YieldQueueAfter = 50; // worker will attempt to process
// 50 work item per queue before dropping it
// and move to the next.
// if a queue stays empty more than .. it will be removed
this.WorkManager.RemoveEmptyQueueAfter = TimeSpan.FromSeconds(10);
// start it
await this.WorkManager.StartAsync();
// this wire up Event hub listeners that uses EventHubListenerDataHandler to
// post to WorkManager which then (create or get existing queue) then en-queue.
this.eventHubListenerHandler = new EventHubListenerDataHandler(this.WorkManager);
// this ensures that an event hub listener is created
// per every assigned event hub
await this.RefreshListenersAsync();
while (!cancellationToken.IsCancellationRequested)
{
await Task.Delay(2000);
}
this.TraceWriter.EnablePrefix = false;
this.TraceWriter.TraceMessage("Replica is existing, stopping the work manager");
try
{
await this.ClearEventHubListeners();
await this.WorkManager.StopAsync();
}
catch (AggregateException aex)
{
AggregateException ae = aex.Flatten();
this.TraceWriter.TraceMessage(
string.Format(
"as the replica unload (run async canceled) the followng errors occured E:{0} StackTrace:{1}",
aex.GetCombinedExceptionMessage(),
aex.GetCombinedExceptionStackTrace()));
}
}
void Awake()
{
if (manager != null)
{
DebugOutput.Shout("WARNING, there is already a WorkManager in system");
}
manager = this;
workQueue = new List<Work>();
}
void Start()
{
TimeScaleHistoric = TimeScale;
roomHolder = GameObject.Find("LevelobjectHolder");
agentHolder = GameObject.Find("AgentHolder");
gadgetHolder = GameObject.Find("GadgetHolder");
destroyHolder = GameObject.Find("DestroyHolder");
placer = GameObject.Find("Placer");
guiscript = GameObject.Find("GUI").GetComponent<Gui>();
gResScript = GameObject.Find("Level").GetComponent<GlobalResources>();
workManagerScript = GameObject.Find("Level").GetComponent<WorkManager>();
}
protected override async Task RunAsync(CancellationToken cancellationToken)
{
this.TraceWriter.EnablePrefix = true;
#if _WAIT_FOR_DEBUGGER
while (!Debugger.IsAttached)
await Task.Delay(5000);
#endif
// Create a work manager that is expected to receive a work item of type RouteToActor
// The work manager will queue them (according to RouteToActor.Queue Name property). Then for each work
//item de-queued it will use RouteToActorWorkItemHandler type to process the work item
this.WorkManager = new WorkManager<RoutetoActorWorkItemHandler, RouteToActorWorkItem>(this.StateManager, this.TraceWriter);
/*
Work Manager supports 2 modes
Buffered:
- the original mode, items are buffered in reliable queues (one per device) then routed to actors.
- the advantages of this mode, if you have smaller # of devices, the system will attempt to avoid the turn based concurrancy of the actor
by fanning out execution, events are picked up from event hub faster than they are delivered to actors. this mode is good for large
# of devices each is a high freq message sender.
Buffered os faster on multi core CPUs , the max # of worker is 2 X CPU ore.
None Buffered Mode:
- newly introcuced mode, events are not buffered and routed directly to actors. this is a better mode if you expect large # of devices.
- You can extend the code to support switching at runtime (example: dealing with variable device #)
*/
this.WorkManager.BufferedMode = false;
// work manager will creates a new (RoutetoActorWorkItemHandler)
// per queue. our work item handling is basically forwarding event hub message to the Actor.
// since each Actor will have it is own queue (and a handler). each handler
// can cache a reference to the actor proxy instead of caching them at a higher level
this.WorkManager.WorkItemHandlerMode = WorkItemHandlerMode.PerQueue;
// maximum # of worker loops (loops that de-queue from reliable queue)
this.WorkManager.MaxNumOfWorkers = WorkManager<RoutetoActorWorkItemHandler, RouteToActorWorkItem>.s_Max_Num_OfWorker;
this.WorkManager.YieldQueueAfter = 50; // worker will attempt to process
// 50 work item per queue before dropping it
// and move to the next.
// if a queue stays empty more than .. it will be removed
this.WorkManager.RemoveEmptyQueueAfter = TimeSpan.FromSeconds(10);
// start it
await this.WorkManager.StartAsync();
// this wire up Event hub listeners that uses EventHubListenerDataHandler to
// post to WorkManager which then (create or get existing queue) then en-queue.
this.eventHubListenerHandler = new EventHubListenerDataHandler(this.WorkManager);
// this ensures that an event hub listener is created
// per every assigned event hub
await this.RefreshListenersAsync();
while (!cancellationToken.IsCancellationRequested)
{
await Task.Delay(2000);
}
this.TraceWriter.EnablePrefix = false;
this.TraceWriter.TraceMessage("Replica is existing, stopping the work manager");
try
{
await this.ClearEventHubListeners();
await this.WorkManager.StopAsync();
}
catch (AggregateException aex)
{
AggregateException ae = aex.Flatten();
this.TraceWriter.TraceMessage(
string.Format(
"as the replica unload (run async canceled) the followng errors occured E:{0} StackTrace:{1}",
aex.GetCombinedExceptionMessage(),
aex.GetCombinedExceptionStackTrace()));
}
}
protected void baseInit()
{
OffsetX = 0.5f* ((SizeX+1f)%2f);
OffsetY = -0.5f* ((SizeY+1f)%2f);
if(gResScript == null){ // piestartee statiskaas references uz singltoniem
gResScript = GameObject.Find("Level").GetComponent<GlobalResources>();
workManagerScript = GameObject.Find("Level").GetComponent<WorkManager>();
levelscript = GameObject.Find("Level").GetComponent<Level>();
roomHolder = GameObject.Find("LevelobjectHolder");
agentHolder = GameObject.Find("AgentHolder");
gadgetHolder = GameObject.Find("GadgetHolder");
}
//peec kolaidera izmeera izreekjinaas objekta kanonisko izmeeru
BoxCollider collider = transform.GetComponent<BoxCollider>();
SizeX = collider.size.x;
SizeY = collider.size.y;
SizeZ = collider.size.z;
Generation = new Dictionary<Res, float>();
Usage = new Dictionary<Res, float>();
foreach (Res r in Enum.GetValues(typeof(Res))){
Generation[r] = 0;
Usage[r] = 0;
}
// prefabaa dfineetos mainiigos saliek Dictaa, pisnis, bet iebuuveetais inspektors neraada sarezshgiitas datu struktuuras [dictionary]
Generation[Res.air] = resourceInitInfo.GenerationAir;
Generation[Res.electricity] = resourceInitInfo.GenerationElectricity;
Generation[Res.water] = resourceInitInfo.GenerationWater;
Usage[Res.air] = resourceInitInfo.UsageAir;
Usage[Res.electricity] = resourceInitInfo.UsageElectricity;
Usage[Res.water] = resourceInitInfo.UsageWater;
AgentNeedsGeneration = new float[AgentNeeds.numTypes];
AgentNeedsGeneration[(int)AgentNeeds.Types.Water] = resourceInitInfo.AgentNeedsWater;
AgentNeedsGeneration[(int)AgentNeeds.Types.Sleep] = resourceInitInfo.AgentNeedsSleep;
}
protected virtual void Awake()
{
if (GameManager.canvasManager != null)
{
Transform t = GameManager.canvasManager.GetSubMenu("ActionSelector");
if (t != null)
{
menu = t.GetComponent<ActionSelectorMenu>();
if (menu != null)
{
menu.manager = this;
DebugOutput.Shout("WorkManager# ActionSelectorMenu is acquired");
}
}
}
workManager = GameManager.workManager;
workType = WorkerPrefabCollection.prefabCollection.WorkGroups[0];
workBrush = Vector3.one;
brushCube = new GLCube(CameraNavigator.focusPoint, workBrush, Color.white, this);
workTypes = WorkerPrefabCollection.prefabCollection.WorkGroups;
/*
if (!safetyCheck())
{
DebugOutput.Shout("Killing this gameObject " + name);
GameObject.Destroy(gameObject);
}*/
SetWorkType(actionType);
}
