protected override void PerformSerialization(NetDataWriter w)
{
w.Put(_playerId);
//We do not send the current player
w.Put(_players.Count - 1);
foreach (Player p in _players)
{
if (p.Id == _playerId)
{
continue;
}
w.Put(p.Id);
w.Put(p.Name);
w.Put(p.Position);
}
if (ResourceSpawner.HasNodes())
{
var nodes = ResourceSpawner.List();
w.Put(nodes.Length);
foreach (ResourceNode node in nodes)
{
w.Put(node.Position);
}
}
else
{
w.Put(0);
}
}
private void Awake()
{
if (Instance != null)
{
Debug.LogError("Error: More than one Resource Spawner in scene!");
return;
}
Instance = this;
}
private void Awake()
{
if (instance == null)
{
instance = this;
}
else
{
Destroy(gameObject);
throw new System.Exception("can't have a second resource spawner destroying the second one");
}
}
protected virtual void OnSceneGUI()
{
ResourceSpawner resTarget = (ResourceSpawner)target;
EditorGUI.BeginChangeCheck();
Vector3 newSpawnLocation = Handles.PositionHandle(resTarget.transform.TransformPoint(resTarget.spawnPosition), Quaternion.identity);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(resTarget, "Change Spawn Position");
resTarget.spawnPosition = resTarget.transform.InverseTransformPoint(newSpawnLocation);
}
}
private void OnMined(Vector2Int position, byte resourceId)
{
$"Has mined resource {resourceId}".Log(_p);
Resource r = Config.Resources[resourceId];
_p.Send(new ServerGiveItems(position, resourceId, (ushort)new Random().Next(r.MinAmount, r.MaxAmount)),
DeliveryMethod.ReliableUnordered);
_interactions.Remove(position);
GameManager.GameServer.Broadcast(new ResourceRemovedPacket(position));
ResourceSpawner.Add(position, resourceId);
}
public void InteractResource(Vector2Int position, byte resourceId)
{
if (ResourceSpawner.IsOnCooldown(position, resourceId))
{
return;
}
if (!_interactions.ContainsKey(position))
{
_interactions.Add(position, new ResourceInteraction(resourceId));
}
//Resource has been mined until the end, giving player resource
if (!_interactions[position].Interact())
{
return;
}
OnMined(position, resourceId);
}
public void LoadBases(List <SaveManager.BaseData> bases, TimeSpan difference, int totalAgents)
{
gameManager = GameManager.Instance;
Debug.Log("Loading Bases! bases count: " + bases.Count);
ResourceSpawner resourceSpawner = GameObject.Find("ResourceSpawner").GetComponent <ResourceSpawner>();
float totalRes = 0.0f;
for (int i = 0; i < bases.Count; i++)
{
SaveManager.BaseData data = bases[i];
GameObject asset = Resources.Load("Base_" + data.baseTypeString) as GameObject;
BuildBase(asset, data.position, out Base b);
allBases.Add(b);
b.LoadSetup(data, difference, resourceSpawner.spawnRate, totalAgents, out float maxResourcesCollected);
totalRes += maxResourcesCollected;
}
//total available spawns
float A = (100 / (resourceSpawner.spawnRate / gameManager.resourceSpawner.resourceSpawnRateUpgrade) / (float)totalAgents);
float ratioAvailable = A / totalRes;
if (ratioAvailable > 1.0f)
{
ratioAvailable = 1.0f;
}
else
{
Debug.Log("Not enough resources available for maximum returns. Upgrade Resource spawn rate!");
}
//Load setup 2 needs information gathered from all bases/agents to calculate gains.
for (int i = 0; i < allBases.Count; i++)
{
allBases[i].LoadSetupFinalize(ratioAvailable);
}
}
// Start is called before the first frame update
void Start()
{
agentStages[currentStage].SetActive(true);
resourceSpawner = GameObject.FindGameObjectWithTag("ResourceSpawner").GetComponent <ResourceSpawner>();
}
void EditTile(Vector2Int tile, ToolType tool, bool deleteOldTile)
{
if (tool == ToolType.SpawnAgents)
{
return;
}
if (map.IsInsideMap(tile) == false)
{
return;
}
if (deleteOldTile)
{
MapTile currentTile = map.GetMapTile(tile);
if (currentTile.isResourceSpawner)
{
resourceNavigator.targets.Remove(tile);
for (int i = 0; i < resourceSpawners.Count; i++)
{
if (resourceSpawners[i].position == tile)
{
resourceSpawners[i].destroyed = true;
resourceSpawners.RemoveAt(i);
resourceSpawnerMatrices.RemoveAt(i);
break;
}
}
}
else if (currentTile.moveCost == map.maxCost)
{
int index = walls.IndexOf(tile);
walls.RemoveAt(index);
wallMatrices.RemoveAt(index);
}
else if (currentTile.pathType == PathType.Crafter)
{
int index = crafterPathTiles.IndexOf(tile);
crafterPathTiles.RemoveAt(index);
crafterPathMatrices.RemoveAt(index);
for (int i = 0; i < flowFields.Count; i++)
{
if (flowFields[i].targets.Contains(tile))
{
flowFields.RemoveAt(i);
break;
}
}
}
else if (currentTile.pathType == PathType.Resource)
{
int index = resourcePathTiles.IndexOf(tile);
resourcePathTiles.RemoveAt(index);
resourcePathMatrices.RemoveAt(index);
for (int i = 0; i < flowFields.Count; i++)
{
if (flowFields[i].targets.Contains(tile))
{
Debug.Log("removing flow target");
flowFields[i].targets.Remove(tile);
}
}
}
else
{
// process of elimination: this tile must be a crafter
for (int i = 0; i < crafters.Count; i++)
{
if (crafters[i].position == tile)
{
crafters[i].destroyed = true;
crafters.RemoveAt(i);
crafterMatrices.RemoveAt(i);
break;
}
}
}
}
MapTile newTile = new MapTile();
newTile.pathType = PathType.Default;
newTile.moveCost = 1;
if (tool == ToolType.Empty)
{
// nothing to see here
}
else if (tool == ToolType.Wall)
{
newTile.moveCost = map.maxCost;
walls.Add(tile);
wallMatrices.Add(GetTileMatrix(tile));
}
else if (tool == ToolType.Crafter)
{
Crafter crafter = new Crafter(tile);
crafter.navigator = new FlowField(map, tile, PathType.Crafter);
crafters.Add(crafter);
crafterMatrices.Add(GetTileMatrix(tile));
flowFields.Add(crafter.navigator);
}
else if (tool == ToolType.Resource)
{
ResourceSpawner spawner = new ResourceSpawner(tile);
newTile.isResourceSpawner = true;
resourceNavigator.targets.Add(tile);
resourceSpawners.Add(spawner);
resourceSpawnerMatrices.Add(GetTileMatrix(tile));
}
else if (tool == ToolType.CrafterPath)
{
newTile.pathType = PathType.Crafter;
crafterPathTiles.Add(tile);
crafterPathMatrices.Add(GetTileMatrix(tile));
}
else if (tool == ToolType.ResourcePath)
{
newTile.pathType = PathType.Resource;
resourcePathTiles.Add(tile);
resourcePathMatrices.Add(GetTileMatrix(tile));
}
map.SetMapTile(tile, newTile);
}
private void VerifyIfTouchingResource()
{
Vector2 dir;
if (_spriteRenderer.flipX)
{
dir = -transform.right;
}
else
{
dir = transform.right;
}
Debug.DrawRay(transform.position, dir);
RaycastHit2D hit = Physics2D.Raycast(transform.position, dir, _spriteWidth / 2 + 0.3f, _resourceLayer);
// If it hits something...
if (hit.collider != null)
{
if (hit.transform.tag == "resource")
{
_currentResource = hit.transform.gameObject.GetComponent <ResourceSpawner>();
if (_currentResource == null)
{
return;
}
if (!_currentResource.IsEmpty() && !_isTouchingResource)
{
_isTouchingResource = true;
ShowResourceCommand();
}
if (!_currentResource.IsEmpty())
{
if ((hit.point - (Vector2)transform.position).magnitude <= 0.2f)
{
isTouchingResource?.Invoke(true);
}
}
if (_currentResource.IsEmpty() && _isTouchingResource)
{
isTouchingResource?.Invoke(false);
_isTouchingResource = false;
HideResourceCommand();
}
return;
}
}
if (_isTouchingResource)
{
_isTouchingResource = false;
isTouchingResource?.Invoke(false);
HideResourceCommand();
_currentResource = null;
_timerSpentGathering = 0;
}
}
// Use this for initialization
void Start()
{
poopcomponent = Pooper.GetComponent <ResourceSpawner> ();
FPS = FPSp.GetComponent <TextMesh> ();
Pods = Podsp.GetComponent <TextMesh> ();
}
