/// <summary>
/// Executes the specified action against
/// the current context and captures an output string.
/// </summary>
/// <param name="block">The action to execute</param>
/// <param name="parameter">The parameter for the action.</param>
public string Block <T>(Action <T> block, T parameter)
{
BlockRenderer br =
new BlockRenderer(_context.Context);
return(br.Capture(() => block(parameter)));
}
/// <summary>
/// Executes the specified action against
/// the current context and captures an output string.
/// </summary>
/// <param name="block">The action to execute</param>
/// <param name="arg1">The first argument of the action.</param>
/// <param name="arg2">The second argument of the action.</param>
/// <param name="arg3">The third argument of the action.</param>
public string Block <T1, T2, T3>(Action <T1, T2, T3> block, T1 arg1, T2 arg2, T3 arg3)
{
BlockRenderer br =
new BlockRenderer(_context.Context);
return(br.Capture(() => block(arg1, arg2, arg3)));
}
/// <summary>
/// Executes the specified action against
/// the current context and captures an output string.
/// </summary>
/// <param name="block">The action to execute</param>
public string Block(Action block)
{
BlockRenderer br =
new BlockRenderer(_context.Context);
return(br.Capture(block));
}
public void RenderTransparent(bool cache)
{
if (_cached2 || (_displayList2.Cached && !cache))
{
_displayList2.Call();
}
else if (cache)
{
_displayList2.Begin();
GL.Begin(BeginMode.Quads);
for (int x = 0; x < Width; ++x)
{
for (int y = 0; y < Depth; ++y)
{
for (int z = 0; z < Height; ++z)
{
Blocktype type = GetBlocktype(x, y, z);
if (type != Blocktype.Water &&
type != Blocktype.StillWater &&
type != Blocktype.Ice)
{
continue;
}
BlocktypeInfo info = BlocktypeInfo.Find(type);
BlockRenderer.Render(this, info, x, y, z);
}
}
}
GL.End();
_displayList2.End();
_cached2 = true;
}
}
private void reloadColor(BlockRenderer blockrenderer, bool respawn)
{
Color color = Color.black;
if (provisionalblockmap[blockrenderer.x][blockrenderer.y] != null)
{
color += color_plus;
}
if (blockrenderer.x == focus_x && blockrenderer.y == focus_y)
{
color += color_focus;
}
if (blockrenderer.x == select_x && blockrenderer.y == select_y)
{
color += color_select;
}
if (color == Color.black)
{
if (respawn)
{
blockrenderer.reload();
}
}
else
{
setBlockColor(blockrenderer.gameObject, color);
}
}
public void SetupBoard(int width, int height)
{
board = new int[width, height];
for (int xi = 0; xi < board.GetLength(0); xi++)
{
for (int yi = 0; yi < board.GetLength(1); yi++)
{
if (yi == 0 && xi == 0)
{
board[xi, yi] = PASSABLE;
}
else if (xi - yi >= 0 && xi - yi < 4)
{
board[xi, yi] = xi - yi;
BlockRenderer blockRenderer = Instantiate <BlockRenderer>(blockRendererPrefab);
blockRenderer.position = new IntVector2(xi, yi);
blockRenderer.transform.position = new Vector3(xi, yi, yi);
}
else
{
board[xi, yi] = PASSABLE;
}
Debug.Log(xi + " " + yi + " " + board[xi, yi]);
}
}
}
public GraphicsWindow(GraphicsService graphicsService, TileService tileService, PalettesService palettesService)
{
InitializeComponent();
_graphicsService = graphicsService;
_tileService = tileService;
_paletteService = palettesService;
_graphicsAccessor = new GraphicsAccessor(_graphicsService.GetTilesAtAddress(0));
_graphicsRenderer = new GraphicsSetRender(_graphicsAccessor);
_blockRenderer = new BlockRenderer();
Dpi dpi = this.GetDpi();
_graphicsBitmap = new WriteableBitmap(128, 128, dpi.X, dpi.Y, PixelFormats.Bgra32, null);
_editorBitmap = new WriteableBitmap(16, 16, dpi.X, dpi.Y, PixelFormats.Bgra32, null);
PatternTable.Source = _graphicsBitmap;
EditorImage.Source = _editorBitmap;
LoadPalettes();
GraphicsType.SelectedIndex = LayoutOrder.SelectedIndex = 0;
_paletteService.PalettesChanged += _paletteService_PalettesChanged;
}
/// <summary>
/// Instantiates wall block renderers that are behind given block renderer.
/// </summary>
/// <param name="blockRenderer"></param>
public void InstantiateFarWallBlocks(BlockRenderer blockRenderer, bool renderImmideately = false)
{
List <BlockRenderer> wallBlocks = new List <BlockRenderer>();
List <BlockRenderer> instantiatedBlockRenderers = new List <BlockRenderer>();
wallBlocks.Add(blockRenderer);
for (int i = 0; i < WALL_BLOCK_RENDER_DEPTH; i++)
{
if (i > 0)
{
wallBlocks = new List <BlockRenderer>();
wallBlocks.AddRange(instantiatedBlockRenderers);
instantiatedBlockRenderers.Clear();
}
foreach (BlockRenderer renderer in wallBlocks)
{
instantiatedBlockRenderers.AddRange(InstantiateNearbyWallBlockRenderers(renderer));
if (renderImmideately)
{
instantiatedBlockRenderers.ForEach(x => x.Render());
}
}
wallBlocks = new List <BlockRenderer>();
wallBlocks.AddRange(instantiatedBlockRenderers);
instantiatedBlockRenderers.Clear();
}
}
void Start()
{
var mapGenerator = GetComponent <MapGenerator>();
blockRenderer = GetComponent <BlockRenderer>();
stats = GetComponent <PlayerStatistics>();
spawnSerializer = GetComponent <SpawnSerializer>();
canvasController = GetComponent <GameCanvasController>();
sounds = GetComponent <SoundController>();
map = mapGenerator.Generate(90, 90);
Func <Spawn, VectorI2> GetStart = (s) =>
{
int rndId = UnityEngine.Random.Range(0, s.spawnPoints.Count);
SpawnPoint sp = s.spawnPoints[rndId];
var vec = new VectorI2((int)sp.playerSpawn.x, (int)sp.playerSpawn.y);
map[vec.X, vec.Y] = Constants.Objects.Floor;
var vecRadio = new VectorI2((int)sp.radioSpawn.x, (int)sp.radioSpawn.y);
map[vecRadio.X, vecRadio.Y] = Constants.Objects.Radio;
return(vec);
};
playerPos = GetStart(spawnSerializer.GetSpawn());
blockRenderer.Initialize(SquareIsValid, map, playerPos.X, playerPos.Y);
StartCoroutine(ReduceOxygen());
StartCoroutine(RunDownRadio());
}
public List <BlockRenderer> GetNearestGroundBlockRenderers(BlockRenderer blockRenderer)
{
return(GetNearestBlockRenderers(blockRenderer)
.FindAll(x => x.block.type == BlockType.Ground &&
x.block.coordinates.IsAdjacentTo(blockRenderer.block.coordinates)
));
}
public SystemInfoForm(World world, BlockRenderer renderer)
{
InitializeComponent();
new Thread(() =>
{
while (!IsDisposed)
{
try
{
if (lblInfo.InvokeRequired)
{
lblInfo.Invoke(new Action(delegate
{
lblInfo.Text = $"World generating...\n" +
$"Borders: {world.BorderGenerationTime} ms\n" +
$"Terrain: {world.TerrainGenerationTime} ms\n" +
$"Food: {world.FoodGenerationTime} ms\n" +
$"Plugins: {world.PluginLoadingTime} ms\n" +
$"\n" +
$"Render time: {renderer.DrawTime} ms\n" +
$"Update time: {world.LogicUpdateTime} ms\n";
}));
}
Thread.Sleep(100);
}
catch
{
}
}
})
{
IsBackground = true
}.Start();
}
/// <summary>
/// Begins the breaking of a block.
/// </summary>
public void beginBreak(World world, int x, int y, int z, Block block, int meta)
{
this.meshRenderer.enabled = true;
MeshBuilder meshBuilder = RenderManager.getMeshBuilder();
BlockRenderer renderer = block.renderer;
if (renderer != null && renderer.bakeIntoChunks)
{
Block[] surroundingBlocks = new Block[6];
for (int i = 0; i < 6; i++)
{
Direction d = Direction.all[i];
surroundingBlocks[i] = world.getBlock(x + d.blockPos.x, y + d.blockPos.y, z + d.blockPos.z);
}
renderer.renderBlock(block, meta, meshBuilder, 0, 0, 0, RenderFace.ALL, surroundingBlocks);
this.meshFilter.mesh = meshBuilder.getGraphicMesh();
}
this.transform.position = new Vector3(x, y, z);
//set the right texture
//int x = block.getTexturePos(Direction.UP, 0).x;
//int y = Mathf.Abs(block.getTexturePos(Direction.UP, 0).y - 3);
this.ps.Play();
}
public void OnNearbyBlockChanged(BlockRenderer changedBlock)
{
Debug.Log("OnNearbyBlockChanged " + block.coordinates);
if (changedBlock.block.type == BlockType.Ground)
{
if (!isRendered)
{
Render();
}
else if (block.type == BlockType.RockShale)
{
Debug.Log("BlockRenderer -> OnNearbyBlockChanged() -> Send 'RenderBlockParts' to " + block.coordinates + " (" + block.type + ")");
_blockModel.gameObject.SendMessage("RenderBlockParts");
}
}
if (changedBlock.block.type == BlockType.RockShale)
{
if (block.type == BlockType.RockShale)
{
if (hasGroundNearby)
{
Render();
}
else if (isRendered)
{
Destroy(_blockModel);
}
}
}
}
static TorchRenderer()
{
BlockRenderer.RegisterRenderer(TorchBlock.BlockID, new TorchRenderer());
for (int i = 0; i < Texture.Length; i++)
{
Texture[i] /= 256f;
}
}
static CraftingTableRenderer()
{
BlockRenderer.RegisterRenderer(CraftingTableBlock.BlockID, new CraftingTableRenderer());
for (int i = 0; i < Texture.Length; i++)
{
Texture[i] *= new Vector2(16f / 256f);
}
}
static LadderRenderer()
{
BlockRenderer.RegisterRenderer(LadderBlock.BlockID, new LadderRenderer());
for (int i = 0; i < Texture.Length; i++)
{
Texture[i] *= new Vector2(16f / 256f);
}
}
static SnowRenderer()
{
BlockRenderer.RegisterRenderer(SnowfallBlock.BlockID, new SnowRenderer());
for (int i = 0; i < Texture.Length; i++)
{
Texture[i] *= new Vector2(16f / 256f);
}
}
static VegitationRenderer()
{
BlockRenderer.RegisterRenderer(DandelionBlock.BlockID, new VegitationRenderer());
BlockRenderer.RegisterRenderer(RoseBlock.BlockID, new VegitationRenderer());
BlockRenderer.RegisterRenderer(TallGrassBlock.BlockID, new VegitationRenderer());
BlockRenderer.RegisterRenderer(DeadBushBlock.BlockID, new VegitationRenderer());
BlockRenderer.RegisterRenderer(SaplingBlock.BlockID, new VegitationRenderer());
}
public void Start(BlockRenderer blockRenderer)
{
Stop();
_blockRenderer = blockRenderer;
Reorg();
UpdateWeeklyArenaState();
}
static LeavesRenderer()
{
BlockRenderer.RegisterRenderer(LeavesBlock.BlockID, new LeavesRenderer());
for (int i = 0; i < BaseTextures.Length; i++)
{
BaseTextures[i] *= new Vector2(16f / 256f);
SpruceTextures[i] *= new Vector2(16f / 256f);
}
}
static WaterRenderer()
{
BlockRenderer.RegisterRenderer(WaterBlock.BlockID, new WaterRenderer());
BlockRenderer.RegisterRenderer(StationaryWaterBlock.BlockID, new WaterRenderer());
for (int i = 0; i < Texture.Length; i++)
{
Texture[i] *= new Vector2(16f / 256f);
}
}
static FarmlandRenderer()
{
BlockRenderer.RegisterRenderer(FarmlandBlock.BlockID, new FarmlandRenderer());
for (int i = 0; i < DryTexture.Length; i++)
{
DryTexture[i] *= new Vector2(16f / 256f);
MoistTexture[i] *= new Vector2(16f / 256f);
}
}
public void BlockRendererTest()
{
var blockRenderer = new BlockRenderer();
var branchPointBlock = new Block <NCAction>(
index: 9,
difficulty: 10000,
totalDifficulty: 90000,
nonce: new Nonce(new byte[] { 0x00, 0x00, 0x00, 0x01 }),
miner: default,
static LogRenderer()
{
BlockRenderer.RegisterRenderer(WoodBlock.BlockID, new LogRenderer());
for (int i = 0; i < BaseTexture.Length; i++)
{
BaseTexture[i] *= new Vector2(16f / 256f);
SpruceTexture[i] *= new Vector2(16f / 256f);
BirchTexture[i] *= new Vector2(16f / 256f);
}
}
public void OnRenderBlock(byte[] oldTip, byte[] newTip)
{
var newTipHeader = BlockHeader.Deserialize(newTip);
BlockIndex = newTipHeader.Index;
BlockIndexSubject.OnNext(BlockIndex);
BlockTipHash = new HashDigest <SHA256>(newTipHeader.Hash);
BlockTipHashSubject.OnNext(BlockTipHash);
_lastTipChangedAt = DateTimeOffset.UtcNow;
BlockRenderer.RenderBlock(null, null);
}
public PlayingScene()
{
var blockRenderer = new BlockRenderer(new Vector2(30));
_boardRenderer = new BoardRenderer(blockRenderer);
_pieceRenderer = new PieceRenderer(blockRenderer);
_dissolvingBoardRowRenderer = new DissolvingBoardRowRenderer(_boardRenderer, blockRenderer);
_fallInterval = new Interval(TimeSpan.FromMilliseconds(300), FallPiece);
_createFallingPieceTimer = new Timer(TimeSpan.FromMilliseconds(300), CreateFallingPiece);
}
/// <summary>
/// Constructs a new DelegatedStimulus.
/// </summary>
/// <param name="stimulusID">Stimulus generation ID</param>
/// <param name="units"></param>
/// <param name="parameters">Stimulus parameters</param>
/// <param name="blockRender">BlockRender delegate method</param>
/// <param name="duration">Duration delegate method</param>
public DelegatedStimulus(string stimulusID, string units, IDictionary <string, object> parameters, BlockRenderer blockRender, DurationCalculator duration)
: base(stimulusID, units, parameters)
{
if (blockRender == null || duration == null)
{
throw new ArgumentException("Delegates may not be null");
}
BlockDelegate = blockRender;
DurationDelegate = duration;
}
public void MineBlock(BlockRenderer renderer)
{
Debug.Log("CharacterControl -> MineBlock");
StopAllActions();
if (!character.inventory.IsFull && GameController.Singleton.isShiftActive)
{
currentActions.Add(new MineAction(renderer, this));
}
}
public RenderSubscriber(
NineChroniclesNodeService nodeService,
MySqlStore mySqlStore
)
{
_blockRenderer = nodeService.BlockRenderer;
_actionRenderer = nodeService.ActionRenderer;
_exceptionRenderer = nodeService.ExceptionRenderer;
_nodeStatusRenderer = nodeService.NodeStatusRenderer;
MySqlStore = mySqlStore;
}
static GrassRenderer()
{
BlockRenderer.RegisterRenderer(GrassBlock.BlockID, new GrassRenderer());
for (int i = 0; i < Texture.Length; i++)
{
Texture[i] *= new Vector2(16f / 256f);
}
for (int i = 0; i < Texture.Length; i++)
{
SnowTexture[i] *= new Vector2(16f / 256f);
}
}
public WorldRenderer()
{
BlockRenderer = new BlockRenderer();
}
/// <summary>
/// Constructs a new DelegatedStimulus.
/// </summary>
/// <param name="stimulusID">Stimulus generation ID</param>
/// <param name="units">Units of the stimulus</param>
/// <param name="sampleRate">Sample rate of the stimulus</param>
/// <param name="parameters">Stimulus parameters</param>
/// <param name="blockRender">BlockRender delegate method</param>
/// <param name="duration">Duration delegate method</param>
public DelegatedStimulus(string stimulusID, string units, IMeasurement sampleRate, IDictionary<string, object> parameters, BlockRenderer blockRender, DurationCalculator duration)
: base(stimulusID, units, parameters)
{
if (blockRender == null || duration == null)
{
throw new ArgumentException("Delegates may not be null");
}
if (sampleRate == null)
throw new ArgumentNullException("sampleRate");
_sampleRate = sampleRate;
BlockDelegate = blockRender;
DurationDelegate = duration;
}
protected virtual void Awake()
{
Renderer = GetComponent<BlockRenderer>();
Renderer.SetMaterial(MapManager.Instance.GetBlockMaterialSampleCopy());
}
