void Start()
{
inventory = GetComponent <InventoryComponent>();
if (inventory)
{
inventoryObserver = new SimpleObserver <InventoryUpdateEvent>(inventory, OnInventoryUpdate);
}
actor = GetComponent <GridActor>();
if (actor)
{
transform.position = actor.Position;
}
if (!data.hasSpawnedRequest)
{
MoveItemRequest req = new MoveItemRequest(data.itemRequired, actor.Position, actor.Guid);
data.requestGuid = req.Guid;
MoveItemRequestPool.Instance.PostRequest(req);
data.hasSpawnedRequest = true;
}
myObserver = new SimpleObserver <RequestPoolUpdateEvent <MoveItemRequest> >(MoveItemRequestPool.Instance, (updateEvent) =>
{
if (updateEvent.Type == RequestPoolUpdateEvent <MoveItemRequest> .EventType.Cancelled && updateEvent.Request.Guid.Equals(data.requestGuid))
{
data.requestFinished = true;
GameObject.Destroy(gameObject);
}
});
BlockVisualizer visualizer = GetComponent <BlockVisualizer>();
if (visualizer)
{
visualizer.RenderBlock(GetBlock());
}
}
void Start()
{
myRenderer = GetComponent <MeshRenderer>();
actor = GetComponent <GridActor>();
inventory = GetComponent <InventoryComponent>();
if (actor && inventory)
{
inventoryObserver = new SimpleObserver <InventoryUpdateEvent>(inventory, (update) =>
{
if (update.Type == InventoryUpdateEvent.UpdateType.Added)
{
OnItemAdded();
}
else if (update.Type == InventoryUpdateEvent.UpdateType.Removed)
{
OnItemRemoved();
}
});
ItemMap.RegisterInventory(inventory, actor.Position);
transform.position = actor.Position + new Vector3(.25f, -.25f, .25f);
Item mainItem = inventory.GetMostCommonItem();
visualizer = GetComponent <BlockVisualizer>();
visualizer.RenderBlock(mainItem.GetTexturePosition());
}
cameraObserver = new SimpleObserver <CameraController>(Camera.main.GetComponent <CameraController>(), (c) =>
{
if (this.myRenderer && actor)
{
this.myRenderer.enabled = c.PositionShouldBeVisible(actor.Position);
}
});
}
void Start()
{
GridActor actor = Helpers.GetComponent <GridActor>(gameObject, logger);
if (actor)
{
posObserver = new SimpleObserver <Vector3Int>(actor, OnNewPos);
OnNewPos(actor.Position);
}
}
static void Main(string[] args)
{
SimpleSubject simpleSubject = new SimpleSubject();
SimpleObserver simpleObserver1 = new SimpleObserver(simpleSubject);
SimpleObserver simpleObserver2 = new SimpleObserver(simpleSubject);
SimpleObserver simpleObserver3 = new SimpleObserver(simpleSubject);
simpleSubject.Value = 80;
Console.ReadKey();
}
void Start()
{
logger = new LilLogger(typeof(UnbuiltBuildingGhoster).ToString());
observer = new SimpleObserver <PlayerUpdateEvent>(PlayerComponent.Instance, OnPlayerSettingsUpdated);
filter = GetComponent <MeshFilter>();
meshRenderer = GetComponent <MeshRenderer>();
seeThroughShader = PrefabLoader.GetPrefab <Shader>("Shaders/SeeThroughShader");
if (seeThroughShader == null)
{
logger.Log("Unable to load Shaders/SeeThroughShader", LogLevel.Warning);
}
}
public void FacilitySpace_ObjectPlaced_ObserverNotified()
{
var space = new FacilitySpace();
var obs = new SimpleObserver <FacilitySpace>();
var obj = new FacilityObject {
Type = "Floor", ObjectLayer = ObjectLayer.Ground
};
space.Subscribe(obs);
space.Put(obj);
Assert.AreEqual(space, obs.LastUpdate);
}
void Start()
{
source = GetComponent <AudioSource>();
observer = new SimpleObserver <Vector2>(GetComponent <PlayerMovementController>(), (movement) =>
{
if (movement == GetComponent <PlayerMovementController>().MaxPossibleMovement)
{
StartPlaying();
}
else
{
StopPlaying();
}
});
}
public void FacilitySpace_RemoveValuable_ObserverNotified()
{
var space = new FacilitySpace();
var obs = new SimpleObserver <FacilitySpace>();
var valuable = new ValuableFacilityObject {
Type = "Vase", ObjectLayer = ObjectLayer.LowerObject
};
space.Put(valuable);
space.Subscribe(obs);
space.Remove((IValuable)valuable);
Assert.AreEqual(space, obs.LastUpdate);
}
void Update()
{
switch (state)
{
case State.Created:
state = State.GeneratingMap;
logger.Log("generating new map");
GenerationParameters parameters = GetParameters();
MapGenerator generator = new MapGenerator(parameters);
MapGenerationProgress.InstantiateNew(generator);
oldParameters = parameters;
generationTask = Task.Run(() => GridMap.Instance.GenerateMap(generator));
break;
case State.GeneratingMap:
case State.LoadingMap:
if (GridMap.Instance.IsGenerationDone())
{
logger.Log("Map finished generation");
state = State.MapGenerated;
}
break;
case State.MapGenerated:
logger.Log("Creating meshGenerators");
BlockMeshes.LoadMeshes();
createMeshCreators();
UpdateMaxVerticalLevel();
RegenerateMeshes();
state = State.MeshGeneratorsCreated;
cameraObserver = new SimpleObserver <CameraController>(mainCam, (cam) =>
{
UpdateMaxVerticalLevel();
RegenerateMeshes();
});
break;
case State.MeshGeneratorsCreated:
break;
}
if (!oldParameters.Equals(GetParameters()) && generationTask != null && !generationTask.Status.Equals(TaskStatus.Running))
{
regenerateMap = false;
RegenerateMap();
}
}
void Start()
{
logger = new Logging.LilLogger("PauseTextComponent");
text = GetComponent <TMP_Text>();
if (text != null)
{
text.enabled = false;
}
else
{
logger.Log("No text found on PauseTextComponent", Logging.LogLevel.Warning);
}
pauseObserver = new SimpleObserver <bool>(PauseManager.Instance, (paused) =>
{
text.enabled = paused;
});
}
public void FacilitySpace_NoValuableRemoved_ObserverNotNotified()
{
var space = new FacilitySpace();
var obs = new SimpleObserver <FacilitySpace>();
var obj = new FacilityObject {
Type = "Floor", ObjectLayer = ObjectLayer.Ground
};
space.Put(obj);
space.Subscribe(obs);
space.Remove(new FacilityObject {
Type = "Door"
});
Assert.AreEqual(0, obs.UpdateCount);
}
public Tuple <int, int> GetProcessIdAndThreadIdThoughEvent()
{
using (var listener = new ObservableEventListener())
{
var observer = new SimpleObserver <EventEntry>();
listener.EnableEvents(TestEventSource.Log, EventLevel.Informational, EventKeywords.None);
listener.Subscribe(observer);
TestEventSource.Log.Informational("some info");
EventEntry entry;
if (observer.Elements.TryTake(out entry, TimeSpan.FromSeconds(10)))
{
return(Tuple.Create(entry.ProcessId, entry.ThreadId));
}
throw new TimeoutException("timed out waiting for envent");
}
}
void Start()
{
inventory = Helpers.GetComponent <InventoryComponent>(gameObject, logger);
if (inventory)
{
inventoryObserver = new SimpleObserver <InventoryUpdateEvent>(inventory, OnInventoryUpdated);
}
actor = Helpers.GetComponent <GridActor>(gameObject, logger);
if (actor)
{
actor.Move(data.blueprint.Location);
transform.position = actor.Position;
}
if (data.blueprint != null)
{
blueprintPrefab = PrefabLoader.GetPrefab <GameObject>(data.blueprint.PrefabPath);
SetupMesh();
SetupGridActor();
SetupRequests();
}
}
void Start()
{
playerMovement = GetComponent <PlayerMovementController>();
movementObserver = new SimpleObserver <Vector2>(playerMovement, movement =>
{
Vector2 maxMovement = playerMovement.MaxPossibleMovement;
float relativeMovement = movement.magnitude / maxMovement.magnitude;
if (relativeMovement > 0.0001f)
{
animationFrequency = 1 / (initialAnimationFrequency * relativeMovement);
if (Mathf.Sign(movement.x) != Mathf.Sign(transform.localScale.x))
{
transform.localScale = new Vector3(-transform.localScale.x, transform.localScale.y, transform.localScale.z);
}
}
else
{
animationFrequency = 10000;
}
});
spriteRenderer = GetComponent <SpriteRenderer>();
lastSpriteReplaceTime = Time.time;
}
public void AddObserver(SimpleObserver observer)
{
observers.Add(observer);
}
private void Start()
{
mainCam = Camera.main.GetComponent <CameraController>();
blockEffectObserver = new SimpleObserver <BlockEffectMap.BlockEffectUpdate>(BlockEffectMap.Instance, update => OnBlockUpdate(update.Position));
gridMapObserver = new SimpleObserver <BlockUpdate>(GridMap.Instance, update => OnBlockUpdate(update.Position));
}
