public override void RefreshTile(Vec3I gridPos, TM.ITilemap tilemap)
{
Vec2I pos = GridToTile(gridPos);
Vec2I subTile = GridToSubTile(gridPos);
Map.BBTile tile = GetTile(pos);
if (!disableRefresh || HasSprite(tile, pos, subTile))
{
tilemap.RefreshTile(gridPos);
}
if (disableRefresh)
{
return;
}
for (int tx = 0; tx < 2; ++tx)
{
for (int ty = 0; ty < 2; ++ty)
{
Vec2I t = pos + new Vec2I(tx + subTile.x - 1, ty + subTile.y - 1);
if (t != pos)
{
t *= 2;
for (int i = 0; i < 4; ++i)
{
tilemap.RefreshTile(new Vec3I(t.x + (i >> 1), t.y + (i % 2), 0));
}
}
}
}
}
private void SetBuilding(Vec2I pos, IBuilding building)
{
var tileMain = Tile(pos);
if (building == null)
{
building = tileMain.bldgMain;
tileMain = null;
}
foreach (var t in building.bounds.allPositionsWithin)
{
var tile = Tile(t);
tile.bldgMain = null;
tile.bldgAdj = tileMain;
}
if (tileMain != null)
{
tileMain.bldgMain = building;
tileMain.bldgAdj = null;
}
tiler.UpdateBuilding(pos);
}
// TODO: this needs to handle sprite anchor
// TODO: this is kinda jank
// shouldnt be new'ing defs, and we'll end up with duplicate sprites
public static bool SplitSprite(SpriteDef sprite, int height, out SpriteDef lower, out SpriteDef upper)
{
var atlas = sprite.atlas;
var heightTiles = height * atlas.tilesPerUnit;
var rect = sprite.rect;
if (sprite.rect.size.y > heightTiles)
{
lower = new SpriteDef(null, atlas, new Atlas.Rect(
rect.origin,
new Vec2I(rect.size.x, heightTiles),
rect.anchor));
var upperOfs = new Vec2I(0, heightTiles);
upper = new SpriteDef(null, atlas, new Atlas.Rect(
rect.origin + upperOfs,
new Vec2I(rect.size.x, rect.size.y - heightTiles),
rect.anchor - upperOfs));
return(true);
}
lower = upper = null;
return(false);
}
public static RectInt RectInclusive(this Rect rect)
{
Vec2I lower = rect.min.Floor();
Vec2I upper = rect.max.Ceil();
return(new RectInt(lower, upper - lower));
}
private Sprite GetSprite(Map map, Vec2I pos, Vec2I subTile, int frame)
{
BB.Assert(frame < def.spriteFrames.Length);
TerrainDef lambdaDef = def; // C# is dumb
Tiling.TileType ttype = Tiling.GetTileType(pos, subTile, p => IsSame(map, p, lambdaDef));
// TODO: Kludge for water arrangement in atlas
if (def == K_waterDef)
{
switch (ttype)
{
case Tiling.TileType.ConcaveBL: ttype = Tiling.TileType.ConcaveTR; break;
case Tiling.TileType.ConcaveTR: ttype = Tiling.TileType.ConcaveBL; break;
case Tiling.TileType.ConcaveBR: ttype = Tiling.TileType.ConcaveTL; break;
case Tiling.TileType.ConcaveTL: ttype = Tiling.TileType.ConcaveBR; break;
}
}
var spritePos = def.spriteFrames[frame] + Tiling.SpriteOffset(ttype);
return(atlas.GetSprite(spritePos, Vec2I.one));
}
public MetaAtlas(AssetSrc assets)
{
#region Caches
keys = new CacheNonNullable <AnimKey, Atlas.Rect>(
animKey =>
{
var origin = new Vec2I(
OffsetFrame(animKey.frame),
20 - (OriginAnim(animKey.anim) + OffsetDir(animKey.dir)));
return(new Atlas.Rect(
origin * 2,
new Vec2I(2, 2),
new Vec2I(1, 0)));
});
atlases = new Cache <string, Atlas>(
path =>
{
var tex = assets.textures.Get(path);
return(new Atlas(tex, 32, 64));
});
paletteMats = new Cache <int, Material>(
index =>
{
var mat = new Material(assets.spriteShader);
mat.EnableKeyword("_ISPALETTED");
mat.SetFloat("_PaletteOffset", 1 - (index + .5f) / 64f);
mat.SetTexture("_PaletteTex", assets.textures.Get("character/palette"));
return(mat);
});
#endregion
}
// TODO: maybe this goes somewhere else
public SpriteRenderer CreateJobOverlay(Transform parent, Vec2I pos, SpriteDef sprite)
=> CreateSpriteObject(
parent,
pos + new Vec2(.5f, .5f),
"JobOverlay",
sprite,
new Color(.6f, .6f, 1, .5f),
RenderLayer.Highlight);
public void Initialize(UnityEngine.Vector2Int coordinate)
{
if (!_isInitialized)
{
Coordinate = coordinate;
}
_isInitialized = true;
}
public void Init(Vec2 worldPos, Vec2 scPos, IEnumerable <Minion> minions)
{
this.minions = minions.ToList();
BB.Assert(this.minions.Count > 0);
this.targetPos = worldPos.Floor();
this.menuPos = scPos;
this.selection = ctrl.SelectAll(worldPos);
}
public BldgWallDef(
string defName, string name, ItemInfo[] materials,
AtlasDef atlas, Vec2I spriteOrigin)
: base("BB:Wall", defName, name)
{
this.materials = materials;
this.atlas = atlas;
this.spriteOrigin = spriteOrigin;
}
private bool TryTile(Vec2I pos, out Tile tile)
{
tile = null;
if (ValidTile(pos))
{
tile = GetTile(pos);
}
return(tile != null);
}
/// <summary>
/// Creates view as voxeled circle.
/// </summary>
/// <param name="atlas"></param>
private void CreateCircle(Texture2D atlas, int spriteOffset)
{
var atlasWidth = pixelsPerUnit * (int)((radius + 0.5) * 2);
var atlasHeight = pixelsPerUnit * (int)((radius + 0.5) * 2);
//every sprite is divided by specific 2D voxels(pixelsPerUnit, pixelsPerUnit)
// __ __ __
// |__|__|__|
// |__|__|__|
// |__|__|__|
var segmentsInRange = new bool[atlasHeight / pixelsPerUnit * atlasWidth / pixelsPerUnit];
var segmentXIndex = 0;
var segmentYIndex = 0;
var segment1DIndex = 0;
for (var i = 0; i < atlasWidth; i++)
{
for (var j = 0; j < atlasHeight; j++)
{
segmentXIndex = i / pixelsPerUnit;
segmentYIndex = j / pixelsPerUnit;
segment1DIndex = segmentXIndex * atlasHeight / pixelsPerUnit + segmentYIndex;
//skip previously visited segment
if (segmentsInRange[segment1DIndex])
{
continue;
}
//checking if current pixel coordinates are in raw range
if (PixelCoor.Distance(new PixelCoor(i, j), new PixelCoor(atlasWidth / 2, atlasHeight / 2)) / pixelsPerUnit <= radius)
{
//marking segment as "visited"
segmentsInRange[segment1DIndex] = true;
//painting all pixels in visited segment
// __ __ __
// |__|__|__|
// ||||__|__|
// ||||__|__|
for (var x = segmentXIndex * pixelsPerUnit; x < segmentXIndex * pixelsPerUnit + pixelsPerUnit; x++)
{
for (var y = segmentYIndex * pixelsPerUnit; y < segmentYIndex * pixelsPerUnit + pixelsPerUnit; y++)
{
atlas.SetPixel(x + spriteOffset / 2, y + spriteOffset / 2, viewColor);
}
}
}
//set clear pixel if coordinates are out of range
else
{
atlas.SetPixel(i + spriteOffset / 2, j + spriteOffset / 2, Color.clear);
}
}
}
atlas.Apply();
}
void ProcessMouseMoveEvent(short x, short y, byte button)
{
UnityEngine.Vector2Int pos = new UnityEngine.Vector2Int(x, y);
UnityEngine.Vector2Int delta = pos - m_prevMousePos;
InputSystem.QueueStateEvent(RemoteMouse, new MouseState {
position = pos,
delta = delta,
buttons = button
});
m_prevMousePos = pos;
}
public void UpdateTile(Vec2I v)
{
Vec3I gridPos = (v * 2).Vec3();
var vtilePrev = tilemap.GetTile(gridPos) as T;
var vtile = vtilePrev == vtileA ? vtileB : vtileA;
for (int i = 0; i < 4; ++i)
{
tilemap.SetTile(gridPos + new Vec3I(i % 2, i >> 1, 0), vtile);
}
}
public override void OnClick(Vec2 realPos)
{
Vec2I pos = realPos.Floor();
if (ctrl.game.CanPlaceBuilding(selection.Bounds(curDir).AsRect(pos)))
{
var tile = ctrl.game.Tile(pos);
builds.CreateBuild(selection, tile, curDir);
//ctrl.game.AddBuilding(selection.CreateBuilding(tile, curDir));
}
}
protected override TileSprite GetSprite(Map.BBTile tile, Vec2I pos, Vec2I subTile)
{
if (grassSprite == null)
{
var atlas = map.game.assets.atlases.Get(Terrain.K_grassDef.atlas);
Vec2I spritePos = Terrain.K_grassDef.spriteFrames[0] + Tiling.SpriteOffset(Tiling.TileType.Base);
grassSprite = atlas.GetSprite(spritePos, Vec2I.one);
}
return(grassSprite);
}
public Sprite[] GetAnimationSprites(Map map, Vec2I pos, Vec2I subTile)
{
BB.Assert(animated);
var sprites = new Sprite[def.spriteFrames.Length];
for (int i = 0; i < def.spriteFrames.Length; ++i)
{
sprites[i] = GetSprite(map, pos, subTile, i);
}
return(sprites);
}
static public int ctor_s(IntPtr l)
{
try {
UnityEngine.Vector2Int o;
o = new UnityEngine.Vector2Int();
pushValue(l, true);
pushValue(l, o);
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
public int[] CoordToTriangleIndices(BlockCoord coord)
{
//NOTE: Coord is non-nullable
if (coord.x >= 0 && coord.x <= GridWidth &&
coord.y >= 0 && coord.y <= GridHeight)
{
coord = InvertY(coord);
var firstTriangleIndex = (int)(coord.y * GridWidth + coord.x) * 2;
return(new int[] { firstTriangleIndex, firstTriangleIndex + 1 });
}
return(null);
}
public static bool[,] GenAdjData(Vec2I pos, Func <Vec2I, bool> IsSame)
{
bool[,] adj = new bool[3, 3];
for (int ax = 0; ax < 3; ++ax)
{
for (int ay = 0; ay < 3; ++ay)
{
adj[ax, ay] = IsSame(new Vec2I(pos.x + ax - 1, pos.y + ay - 1));
}
}
return(adj);
}
protected override Status OnBeginTask()
{
// TODO: make loading bar
agent.SetTool(tool);
agent.SetAnim(anim);
Vec2I workTarget = faceFn(agent.pos);
if (agent.pos != workTarget)
{
agent.SetFacing(workTarget - agent.pos);
}
return(Status.Continue);
}
private void InitTiles(Vec2I size)
{
BB.AssertNull(tiles);
this.size = size;
tiles = new BBTile[size.x, size.y];
for (int x = 0; x < size.x; ++x)
{
for (int y = 0; y < size.y; ++y)
{
tiles[x, y] = new BBTile(new Vec2I(x, y));
}
}
}
public GridPlaneOrientation(
UnityEngine.Vector2Int size = default,
UnityEngine.Vector3Int offset = default,
float normalOffset = 0f,
int subdivisions = 1
)
{
this.enabled = true;
this.size = size;
this.offset = offset;
this.normalOffset = normalOffset;
this.subdivisions = subdivisions;
}
public override void OnUpdate(Vec2 realMouse)
{
Vec2I mouse = realMouse.Floor();
var bounds = selection.Bounds(curDir);
bool valid =
ctrl.game.ValidTile(mouse) &&
ctrl.game.CanPlaceBuilding(bounds.AsRect(mouse));
var area = bounds.AsRect(mouse);
outlineAllow.SetRect(area);
outlineAllow.enabled = valid;
outlineDisallow.SetRect(area);
outlineDisallow.enabled = !valid;
}
private RectTransform CreateCanvas(Transform parent, Vec2I refSize)
{
var node = Gui.CreateCanvas(parent, refSize);
var obj = node.gameObject;
obj.AddComponent <GraphicRaycaster>();
var events = obj.AddComponent <EventSystem>();
events.sendNavigationEvents = false;
var module = obj.AddComponent <StandaloneInputModule>();
module.forceModuleActive = true;
return(node);
}
protected override void Execute(List <GameEntityG> entities)
{
var board = GameStateScope.Get <BoardG>().value;
for (int x = 0; x < board.x; x++)
{
var position = new Vector2Int(x, board.y);
var nextRowPos = BoardLogic.GetNextEmptyRow(GameScope, position);
while (nextRowPos != board.y)
{
GameScope.CreateRandomPiece(x, nextRowPos);
nextRowPos = BoardLogic.GetNextEmptyRow(GameScope, position);
}
}
}
public BldgWorkbenchDef(
string defName, string name,
BuildingBounds bounds, Vec2I workSpot,
SpriteDef spriteDown, SpriteDef spriteRight,
ItemInfo[] materials,
RecipeDef[] recipes)
: base("BB:Workbench", defName, name)
{
BB.Assert(bounds.IsAdjacent(workSpot));
this.bounds = bounds;
this.workSpot = workSpot;
this.spriteDown = spriteDown;
this.spriteRight = spriteRight;
this.materials = materials;
this.recipes = recipes;
}
public override bool GetTileAnimationData(Vec3I gridPos, TM.ITilemap tilemap, ref TM.TileAnimationData tileAnimationData)
{
Vec2I pos = GridToTile(gridPos);
Terrain terrain = GetTile(pos).terrain;
if (!terrain.animated)
{
return(false);
}
tileAnimationData.animatedSprites = terrain.GetAnimationSprites(map, pos, GridToSubTile(gridPos));
tileAnimationData.animationSpeed = 2;
tileAnimationData.animationStartTime = 0;
return(true);
}
public static RectTransform CreateCanvas(Transform parent, Vec2I refSize)
{
var node = CreateObject(parent, "<canvas>");
var obj = node.gameObject;
var canvas = obj.AddComponent <Canvas>();
canvas.renderMode = RenderMode.ScreenSpaceOverlay;
var scaler = obj.AddComponent <CanvasScaler>();
scaler.uiScaleMode = CanvasScaler.ScaleMode.ScaleWithScreenSize;
scaler.referenceResolution = refSize;
scaler.matchWidthOrHeight = .5f;
return(node);
}
public Agent(Game game, AgentDef def, Vec2I pos, string nodeName)
{
#if DEBUG
D_uniqueID = D_nextID;
++D_nextID;
#endif
this.game = game;
this.def = def;
transform = new GameObject(nodeName).transform;
transform.SetParent(game.agentContainer, false);
realPos = pos;
/* var line = game.assets.CreateLine(
* transform, "DgbBounds", RenderLayer.Highlight,
* Color.blue, 1 / 32f, true, false);
* line.SetCircle(def.bounds, 32);*/
}