private void DrawSearchHighlight(DrawingContext dc, Block block)
{
foreach (var pair in _curSearchMatches)
{
int txtOffset = 0;
double y = block.Y;
for (int i = 0; i < block.Text.Length; i++)
{
int start = Math.Max(txtOffset, pair.Item1);
int end = Math.Min(txtOffset + block.Text[i].Length, pair.Item2);
if (end > start)
{
double x1 = block.Text[i].GetDistanceFromCharacterHit(new CharacterHit(start, 0)) + block.TextX;
double x2 = block.Text[i].GetDistanceFromCharacterHit(new CharacterHit(end, 0)) + block.TextX;
dc.DrawRectangle(_searchBrush.Value, null,
new Rect(new Point(x1, y), new Point(x2, y + _lineHeight)));
}
y += _lineHeight;
txtOffset += block.Text[i].Length;
}
}
}
public BlockUpdate( Player origin, short x, short y, short z, Block blockType ) {
Origin = origin;
X = x;
Y = y;
Z = z;
BlockType = blockType;
}
public BlockUpdate( Player origin, Vector3I coord, Block blockType ) {
Origin = origin;
X = (short)coord.X;
Y = (short)coord.Y;
Z = (short)coord.Z;
BlockType = blockType;
}
/// <summary>
/// Add block override
/// </summary>
/// <param name="block">Block to add</param>
public override void AddBlock(Block block)
{
if (block is Constructor || block is Statement || block is Method)
SubBlocks.Add(block);
else
Logger.Error(LocaString.Get("UnhandledError") + " : CustomObject.cs #1");
}
public SandTask( World world, Vector3I position, Block Type )
: base(world)
{
_pos = position;
_nextPos = position.Z - 1;
_type = Type;
}
public CopyState( Vector3I mark1, Vector3I mark2 ) {
BoundingBox box = new BoundingBox( mark1, mark2 );
Orientation = new Vector3I( mark1.X <= mark2.X ? 1 : -1,
mark1.Y <= mark2.Y ? 1 : -1,
mark1.Z <= mark2.Z ? 1 : -1 );
Buffer = new Block[box.Width, box.Length, box.Height];
}
public UndoBlock( Vector3I coord, Block block )
{
X = (short)coord.X;
Y = (short)coord.Y;
Z = (short)coord.Z;
Block = block;
}
protected override bool Deobfuscate(Block block) {
bool modified = false;
var instructions = block.Instructions;
for (int i = 0; i < instructions.Count; i++) {
var instr = instructions[i];
switch (instr.OpCode.Code) {
// Xenocode generates stloc + ldloc (bool). Replace it with dup + stloc. It will eventually
// become dup + pop and be removed.
case Code.Stloc:
case Code.Stloc_S:
case Code.Stloc_0:
case Code.Stloc_1:
case Code.Stloc_2:
case Code.Stloc_3:
if (i + 1 >= instructions.Count)
break;
if (!instructions[i + 1].IsLdloc())
break;
var local = Instr.GetLocalVar(locals, instr);
if (local.Type.ElementType != ElementType.Boolean)
continue;
if (local != Instr.GetLocalVar(locals, instructions[i + 1]))
break;
instructions[i] = new Instr(OpCodes.Dup.ToInstruction());
instructions[i + 1] = instr;
modified = true;
break;
default:
break;
}
}
return modified;
}
public FireworkParticle(World world, Vector3I pos, Block block)
: base(world)
{
_startingPos = pos;
_nextZ = pos.Z - 1;
_block = block;
}
/// <summary>
/// Generate a chunk and return it. The terrain object remains unmodified.
/// </summary>
/// <param name="terrain">The terrain.</param>
/// <param name="chunkIndex">The chunk index.</param>
/// <returns>The chunk.</returns>
public Chunk GenerateChunk(Terrain terrain, Vector2I chunkIndex)
{
Chunk chunk = new Chunk();
// Calculate the position of the chunk in world coordinates
var chunkPos = new Vector2I(chunkIndex.X * Chunk.SizeX, chunkIndex.Y * Chunk.SizeY);
// Get the surface heights for this chunk
int[] surfaceHeights = this.GenerateSurfaceHeights(chunkPos);
// For now, fill the terrain with mud under the surface
for (int x = 0; x < Chunk.SizeX; x++)
{
int surfaceHeight = surfaceHeights[x];
if (surfaceHeight > 0)
{
for (int y = 0; y < surfaceHeight; y++)
{
chunk[x, y] = new Block(BlockType.Dirt);
}
}
}
return chunk;
}
void Start()
{
filter = gameObject.GetComponent<MeshFilter>();
coll = gameObject.GetComponent<MeshCollider>();
//past here is just to set up an example chunk
blocks = new Block[chunkSize, chunkSize, chunkSize];
for (int x = 0; x < chunkSize; x++)
{
for (int y = 0; y < chunkSize; y++)
{
for (int z = 0; z < chunkSize; z++)
{
blocks[x, y, z] = new BlockAir();
}
}
}
blocks[1, 1, 1] = new Block();
blocks[1, 2, 1] = new Block();
blocks[1, 2, 2] = new Block();
blocks[2, 2, 2] = new Block();
UpdateChunk();
}
public TwitterClient(IRestClient client, string consumerKey, string consumerSecret, string callback)
: base(client)
{
Encode = true;
Statuses = new Statuses(this);
Account = new Account(this);
DirectMessages = new DirectMessages(this);
Favourites = new Favourites(this);
Block = new Block(this);
Friendships = new Friendship(this);
Lists = new List(this);
Search = new Search(this);
Users = new Users(this);
FriendsAndFollowers = new FriendsAndFollowers(this);
OAuthBase = "https://api.twitter.com/oauth/";
TokenRequestUrl = "request_token";
TokenAuthUrl = "authorize";
TokenAccessUrl = "access_token";
Authority = "https://api.twitter.com/";
Version = "1";
#if !SILVERLIGHT
ServicePointManager.Expect100Continue = false;
#endif
Credentials = new OAuthCredentials
{
ConsumerKey = consumerKey,
ConsumerSecret = consumerSecret,
};
if (!string.IsNullOrEmpty(callback))
((OAuthCredentials)Credentials).CallbackUrl = callback;
}
public BlockFloat(World world, Vector3I position, Block Type)
: base(world)
{
_pos = position;
_nextPos = position.Z + 1;
type = Type;
}
private Block[] subDivideBlock(Block originBlock) {
bool xSpace = Mathf.Abs(originBlock.c3.x-originBlock.c1.x) > minimumBlockSize * 2.1;
bool ySpace = Mathf.Abs(originBlock.c3.y-originBlock.c1.y) > minimumBlockSize * 2.1;
float roadWidth = Random.Range(roadWidthMin, roadWidthMax);
if (!xSpace && !ySpace) {
Block b1 = new Block ();
Block b2 = new Block ();
Debug.Assert (b1.IsNull);
Debug.Assert (b2.IsNull);
return new Block[2]{new Block(), new Block()};
}
bool xSplit = (xSpace && Random.value < 0.5f) || !ySpace;
float splitPlace;
if (xSplit) {
splitPlace = Random.Range (originBlock.c1.x+minimumBlockSize, originBlock.c3.x-minimumBlockSize);
Block block1 = new Block (originBlock.c1, new Vector2(splitPlace-roadWidth/2, originBlock.c3.y));
Block block2 = new Block (new Vector2(splitPlace+roadWidth/2, originBlock.c1.y), originBlock.c3);
return new Block[2]{block1,block2};
} else {
splitPlace = Random.Range (originBlock.c1.y+minimumBlockSize, originBlock.c3.y-minimumBlockSize);
Block block1 = new Block (originBlock.c1, new Vector2(originBlock.c3.x, splitPlace-roadWidth/2));
Block block2 = new Block (new Vector2(originBlock.c1.x, splitPlace+roadWidth/2), originBlock.c3);
return new Block[2]{block1,block2};
}
}
private void recursiveBlockDivision(Block block, ArrayList blocks, int loopsLeft) {
if (loopsLeft < 0) {
return;
}
float currentMagnitude = (block.c3 - block.c1).magnitude;
Block[] newBlocks = subDivideBlock (block);
bool subDivide;
if (Mathf.Max ((block.c2 - block.c1).magnitude, (block.c4 - block.c1).magnitude) > maximumBlockSize) { //block too large, subdivide
subDivide = true;
} else if (newBlocks [0].IsNull) { //block can be subdivided, keep it like this
subDivide = false;
blocks.Add (block);
} else {
if (currentMagnitude < minimumBlockSize * 6 && Random.value <= 0.2) {
subDivide = false;
} else if (Random.value <= 0.2) {
subDivide = false;
blocks.Add (block);
} else {
subDivide = true;
}
}
if (subDivide) {
recursiveBlockDivision (newBlocks [0], blocks, loopsLeft - 1);
recursiveBlockDivision (newBlocks [1], blocks, loopsLeft - 1);
}
}
private static Block AddColumn4(Block block)
{
block = block.AddRight(Brushes.White, 96);
Block inner = block.AddInner(Brushes.Red, 390 - 357, 444 - 416, 33, 70);
inner.AddBelow(Brushes.Yellow, 15);
return block;
}
static void Main(string[] args)
{
InitComplements();
var seq = new List<byte[]>();
var b = new Block { Count = -1 };
Index line = Index.None, start = Index.None, end = Index.None;
using (var r = new BinaryReader(Console.OpenStandardInput())) {
using (var w = Console.OpenStandardOutput()) {
while (b.Read(r) > 0) {
seq.Add(b.Data);
if (line.Pos < 0) line = b.IndexOf(Gt, 0);
while (line.Pos >= 0) {
if (start.Pos < 0) {
var off = line.InBlock(b) ? line.Pos : 0;
start = b.IndexOf(Lf, off);
if (start.Pos < 0) {
w.Write(b.Data, off, b.Data.Length - off);
seq.Clear(); break;
}
w.Write(b.Data, off, start.Pos + 1 - off);
}
if (end.Pos < 0) {
end = b.IndexOf(Gt, start.InBlock(b) ? start.Pos : 0);
if (end.Pos < 0) break;
}
w.Reverse(start.Pos, end.Pos, seq);
if (seq.Count > 1) seq.RemoveRange(0, seq.Count - 1);
line = end; end = Index.None; start = Index.None;
}
}
if (start.Pos >= 0 && end.Pos < 0)
w.Reverse(start.Pos, seq[seq.Count -1].Length, seq);
}
}
}
public PixelwiseOrientationField(int[,] bytes, int blockSize)
{
BlockSize = blockSize;
int maxX = bytes.GetUpperBound(1) + 1;
int maxY = bytes.GetUpperBound(0) + 1;
double[,] filterX = new double[,] { { -1, 0, 1 }, { -2, 0, 2 }, { -1, 0, 1 } };
double[,] filterY = new double[,] { { -1, -2, -1 }, { 0, 0, 0 }, { 1, 2, 1 } };
double[,] doubleBytes = new double[maxY, maxX];
for (int row = 0; row < maxY; row++)
{
for (int column = 0; column < maxX; column++)
{
doubleBytes[row, column] = (double)bytes[row, column];
}
}
// градиенты
double[,] Gx = ConvolutionHelper.Convolve(doubleBytes, filterX);
double[,] Gy = ConvolutionHelper.Convolve(doubleBytes, filterY);
// рассчет направления для каждого пикселя
_orientation = new double[maxY, maxX];
// только один блок - персональный для каждого пикселя
for (int centerRow = 0; centerRow < maxY; centerRow++)
{
for (int centerColumn = 0; centerColumn < maxX; centerColumn++)
{
_block = new Block(_orientation, BlockSize, Gx, Gy, centerRow, centerColumn);
}
}
}
private static void DrawBlock(Graphics grph, Block block)
{
foreach (Paragraph para in block.Paragraphs)
DrawParagraph(grph, para);
block.Draw(grph);
}
bool IsSwitchType2(Block switchBlock) {
Local local = null;
foreach (var instr in switchBlock.Instructions) {
if (!instr.IsLdloc())
continue;
local = Instr.GetLocalVar(blocks.Locals, instr);
break;
}
if (local == null)
return false;
foreach (var source in switchBlock.Sources) {
var instrs = source.Instructions;
for (int i = 1; i < instrs.Count; i++) {
var ldci4 = instrs[i - 1];
if (!ldci4.IsLdcI4())
continue;
var stloc = instrs[i];
if (!stloc.IsStloc())
continue;
if (Instr.GetLocalVar(blocks.Locals, stloc) != local)
continue;
return true;
}
}
return false;
}
public static void PlaySoundPlayer(AudioClip clip, bool loop, Block player,
PlayerAudioType type)
{
if (clip == null)
return;
var audio = _instance.PlayerAudioSource;
if (!audio.enabled)
return;
if (player == Block.Player1)
_instance._player1 = type;
else if (player == Block.Player2)
_instance._player2 = type;
if (type == PlayerAudioType.Idle)
if (_instance._player1 == PlayerAudioType.Move ||
_instance._player2 == PlayerAudioType.Move)
return;
if (audio.clip == clip && audio.isPlaying)
return;
audio.loop = loop;
audio.clip = clip;
audio.Play();
}
public void SetBlock (Block block, int x, int y, int z)
{
Chunk chunk = GetChunkWorldPos (x, z);
if (chunk.generated) {
chunk.SetBlockWorldPos (block, x, y, z);
}
}
public void Build(Vector3 pos, int width, int height)
{
for (int i = -10; i < width + 10; i++)
{
for (int j = -10; j < height + 10; j++)
{
GameObject cell = Resources.Load("Cell", typeof(GameObject)) as GameObject;
float x = i * dx, y = j * dy;
if (j % 2 != 0) {
x += dx/2;
}
cell.transform.position = pos + new Vector3(x, y, 0);
GameObject cellClone = Instantiate(cell);
cellClone.GetComponent<CellPosition>().Set(i, j);
Entity e;
if (i < 0 || i >= width || j < 0 || j > height)
e = new Block(Block.BlockType.Water);
else
e = Entity.getRandom();
cellClone.GetComponent<CellContent>().SetEntity(e);
if (i == 0 && j == 0)
Camera.main.GetComponent<CameraMotion>().minpos = cellClone.transform.position;
if (i == width-1 && j == height-1)
Camera.main.GetComponent<CameraMotion>().maxpos = cellClone.transform.position;
}
}
}
internal Mixin(string name, string args, Block block, bool call)
{
Name = name;
// Args = args;
Block = block;
// Call = call;
}
public Zombie(int x, int y)
: base(x, y)
{
updateTimer.Start();
lagTimer.Start();
zombieBlock = Block.CreateBlock(0, xBlock, yBlock, 32, 0);
}
private WorldBlock[, ,] GetEmptyWorld(int sizeX, int sizeY, Block fillBlock, Block borderBlock)
{
var blockArray = new WorldBlock[2, sizeX, sizeY];
int maxX = sizeX - 1;
int maxY = sizeY - 1;
// Fill the middle with GravityNothing blocks
for (var l = Layer.Background; l >= Layer.Foreground; l += -1)
for (int x = 0; x <= maxX; x++)
for (int y = 0; y <= maxY; y++)
NewBlock(blockArray, l, x, y, fillBlock);
// Border drawing
for (int y = 0; y <= maxY; y++)
{
blockArray[0, 0, y].SetBlock(borderBlock);
blockArray[0, maxX, y].SetBlock(borderBlock);
}
for (int x = 0; x <= maxX; x++)
{
blockArray[0, x, 0].SetBlock(borderBlock);
blockArray[0, x, maxY].SetBlock(borderBlock);
}
return blockArray;
}
public static bool CanFloat(Block block)
{
switch (block)
{
case Block.Red:
case Block.Orange:
case Block.Yellow:
case Block.Lime:
case Block.Green:
case Block.Teal:
case Block.Aqua:
case Block.Cyan:
case Block.Blue:
case Block.Indigo:
case Block.Violet:
case Block.Magenta:
case Block.Pink:
case Block.Black:
case Block.Gray:
case Block.White:
case Block.Sponge:
case Block.Wood:
case Block.Leaves:
return true;
default:
return false;
}
}
public static FlowBranching CreateBranching (FlowBranching parent, BranchingType type, Block block, Location loc)
{
switch (type) {
case BranchingType.Exception:
case BranchingType.Labeled:
case BranchingType.Toplevel:
case BranchingType.TryCatch:
throw new InvalidOperationException ();
case BranchingType.Switch:
return new FlowBranchingBreakable (parent, type, SiblingType.SwitchSection, block, loc);
case BranchingType.Block:
return new FlowBranchingBlock (parent, type, SiblingType.Block, block, loc);
case BranchingType.Loop:
return new FlowBranchingBreakable (parent, type, SiblingType.Conditional, block, loc);
case BranchingType.Embedded:
return new FlowBranchingContinuable (parent, type, SiblingType.Conditional, block, loc);
default:
return new FlowBranchingBlock (parent, type, SiblingType.Conditional, block, loc);
}
}
public Player(Arman game, PositionInGrid positionInGrid, Texture2D texture, Block[,] gameArray, int oneBlockSize, int timeForMove, List<Entity> movableObjects, GameArea gameArea, Controls controls)
: base(game, positionInGrid, texture, gameArray, oneBlockSize, timeForMove, movableObjects)
{
this.gameArea = gameArea;
this.controls = controls;
spawnPoint = positionInGrid;
}
/// <summary>
/// Get formatting object for body element
/// </summary>
/// <param name="regionId"></param>
/// <param name="tick"></param>
/// <returns></returns>
public override FormattingObject GetFormattingObject(TimeCode tick)
{
Block block = null;
if (TemporallyActive(tick))
{
block = new Block(this);
foreach (var child in Children)
{
if (child is DivElement)
{
var fo = (child as DivElement).GetFormattingObject(tick);
if (fo != null)
{
fo.Parent = block;
block.Children.Add(fo);
}
}
if (child is SetElement)
{
var fo = ((child as SetElement).GetFormattingObject(tick)) as Animation;
if (fo != null)
{
// fo.Parent = block;
block.Animations.Add(fo);
}
}
}
}
return block;
}
public virtual void ExecuteBlock(ContextInformation context, TaskScheduler taskScheduler)
{
this.logger.LogTrace("()");
Block block = context.BlockResult.Block;
ChainedBlock index = context.BlockResult.ChainedBlock;
DeploymentFlags flags = context.Flags;
UnspentOutputSet view = context.Set;
this.PerformanceCounter.AddProcessedBlocks(1);
taskScheduler = taskScheduler ?? TaskScheduler.Default;
if (flags.EnforceBIP30)
{
foreach (Transaction tx in block.Transactions)
{
UnspentOutputs coins = view.AccessCoins(tx.GetHash());
if ((coins != null) && !coins.IsPrunable)
{
this.logger.LogTrace("(-)[BAD_TX_BIP_30]");
ConsensusErrors.BadTransactionBIP30.Throw();
}
}
}
long nSigOpsCost = 0;
Money nFees = Money.Zero;
List <Task <bool> > checkInputs = new List <Task <bool> >();
for (int txIndex = 0; txIndex < block.Transactions.Count; txIndex++)
{
this.PerformanceCounter.AddProcessedTransactions(1);
Transaction tx = block.Transactions[txIndex];
if (!tx.IsCoinBase && (!context.IsPoS || (context.IsPoS && !tx.IsCoinStake)))
{
int[] prevheights;
if (!view.HaveInputs(tx))
{
this.logger.LogTrace("(-)[BAD_TX_NO_INPUT]");
ConsensusErrors.BadTransactionMissingInput.Throw();
}
prevheights = new int[tx.Inputs.Count];
// Check that transaction is BIP68 final.
// BIP68 lock checks (as opposed to nLockTime checks) must
// be in ConnectBlock because they require the UTXO set.
for (int j = 0; j < tx.Inputs.Count; j++)
{
prevheights[j] = (int)view.AccessCoins(tx.Inputs[j].PrevOut.Hash).Height;
}
if (!tx.CheckSequenceLocks(prevheights, index, flags.LockTimeFlags))
{
this.logger.LogTrace("(-)[BAD_TX_NON_FINAL]");
ConsensusErrors.BadTransactionNonFinal.Throw();
}
}
// GetTransactionSigOpCost counts 3 types of sigops:
// * legacy (always),
// * p2sh (when P2SH enabled in flags and excludes coinbase),
// * witness (when witness enabled in flags and excludes coinbase).
nSigOpsCost += this.GetTransactionSigOpCost(tx, view, flags);
if (nSigOpsCost > this.consensusOptions.MaxBlockSigopsCost)
{
ConsensusErrors.BadBlockSigOps.Throw();
}
// TODO: Simplify this condition.
if (!tx.IsCoinBase && (!context.IsPoS || (context.IsPoS && !tx.IsCoinStake)))
{
this.CheckInputs(tx, view, index.Height);
nFees += view.GetValueIn(tx) - tx.TotalOut;
Transaction localTx = tx;
PrecomputedTransactionData txData = new PrecomputedTransactionData(tx);
for (int inputIndex = 0; inputIndex < tx.Inputs.Count; inputIndex++)
{
this.PerformanceCounter.AddProcessedInputs(1);
TxIn input = tx.Inputs[inputIndex];
int inputIndexCopy = inputIndex;
TxOut txout = view.GetOutputFor(input);
var checkInput = new Task <bool>(() =>
{
if (this.UseConsensusLib)
{
Script.BitcoinConsensusError error;
return(Script.VerifyScriptConsensus(txout.ScriptPubKey, tx, (uint)inputIndexCopy, flags.ScriptFlags, out error));
}
else
{
var checker = new TransactionChecker(tx, inputIndexCopy, txout.Value, txData);
var ctx = new ScriptEvaluationContext();
ctx.ScriptVerify = flags.ScriptFlags;
return(ctx.VerifyScript(input.ScriptSig, txout.ScriptPubKey, checker));
}
});
checkInput.Start(taskScheduler);
checkInputs.Add(checkInput);
}
}
this.UpdateCoinView(context, tx);
}
this.CheckBlockReward(context, nFees, index, block);
bool passed = checkInputs.All(c => c.GetAwaiter().GetResult());
if (!passed)
{
this.logger.LogTrace("(-)[BAD_TX_SCRIPT]");
ConsensusErrors.BadTransactionScriptError.Throw();
}
this.logger.LogTrace("(-)");
}
public virtual void CheckBlockReward(ContextInformation context, Money nFees, ChainedBlock chainedBlock, Block block)
{
this.logger.LogTrace("()");
Money blockReward = nFees + this.GetProofOfWorkReward(chainedBlock.Height);
if (block.Transactions[0].TotalOut > blockReward)
{
this.logger.LogTrace("(-)[BAD_COINBASE_AMOUNT]");
ConsensusErrors.BadCoinbaseAmount.Throw();
}
this.logger.LogTrace("(-)");
}
protected override bool CanRewrite(Block block)
{
return(block.Type == BlockType.Expression && Parent != null);
}
/// <summary>
/// Add a physicsblock to the custom block list
/// </summary>
/// <param name="b"></param>
public static void Add(PhysicsBlock b)
{
Block.Add(b);
}
public virtual void ContextualCheckBlock(ContextInformation context)
{
this.logger.LogTrace("()");
Block block = context.BlockResult.Block;
DeploymentFlags deploymentFlags = context.Flags;
int nHeight = context.BestBlock == null ? 0 : context.BestBlock.Height + 1;
// Start enforcing BIP113 (Median Time Past) using versionbits logic.
DateTimeOffset nLockTimeCutoff = deploymentFlags.LockTimeFlags.HasFlag(Transaction.LockTimeFlags.MedianTimePast) ?
context.BestBlock.MedianTimePast :
block.Header.BlockTime;
// Check that all transactions are finalized.
foreach (Transaction transaction in block.Transactions)
{
if (!transaction.IsFinal(nLockTimeCutoff, nHeight))
{
this.logger.LogTrace("(-)[TX_NON_FINAL]");
ConsensusErrors.BadTransactionNonFinal.Throw();
}
}
// Enforce rule that the coinbase starts with serialized block height.
if (deploymentFlags.EnforceBIP34)
{
Script expect = new Script(Op.GetPushOp(nHeight));
Script actual = block.Transactions[0].Inputs[0].ScriptSig;
if (!this.StartWith(actual.ToBytes(true), expect.ToBytes(true)))
{
this.logger.LogTrace("(-)[BAD_COINBASE_HEIGHT]");
ConsensusErrors.BadCoinbaseHeight.Throw();
}
}
// Validation for witness commitments.
// * We compute the witness hash (which is the hash including witnesses) of all the block's transactions, except the
// coinbase (where 0x0000....0000 is used instead).
// * The coinbase scriptWitness is a stack of a single 32-byte vector, containing a witness nonce (unconstrained).
// * We build a merkle tree with all those witness hashes as leaves (similar to the hashMerkleRoot in the block header).
// * There must be at least one output whose scriptPubKey is a single 36-byte push, the first 4 bytes of which are
// {0xaa, 0x21, 0xa9, 0xed}, and the following 32 bytes are SHA256^2(witness root, witness nonce). In case there are
// multiple, the last one is used.
bool fHaveWitness = false;
if (deploymentFlags.ScriptFlags.HasFlag(ScriptVerify.Witness))
{
int commitpos = this.GetWitnessCommitmentIndex(block);
if (commitpos != -1)
{
bool malleated = false;
uint256 hashWitness = this.BlockWitnessMerkleRoot(block, ref malleated);
// The malleation check is ignored; as the transaction tree itself
// already does not permit it, it is impossible to trigger in the
// witness tree.
WitScript witness = block.Transactions[0].Inputs[0].WitScript;
if ((witness.PushCount != 1) || (witness.Pushes.First().Length != 32))
{
this.logger.LogTrace("(-)[BAD_WITNESS_NONCE_SIZE]");
ConsensusErrors.BadWitnessNonceSize.Throw();
}
byte[] hashed = new byte[64];
Buffer.BlockCopy(hashWitness.ToBytes(), 0, hashed, 0, 32);
Buffer.BlockCopy(witness.Pushes.First(), 0, hashed, 32, 32);
hashWitness = Hashes.Hash256(hashed);
if (!this.EqualsArray(hashWitness.ToBytes(), block.Transactions[0].Outputs[commitpos].ScriptPubKey.ToBytes(true).Skip(6).ToArray(), 32))
{
this.logger.LogTrace("(-)[WITNESS_MERKLE_MISMATCH]");
ConsensusErrors.BadWitnessMerkleMatch.Throw();
}
fHaveWitness = true;
}
}
if (!fHaveWitness)
{
for (int i = 0; i < block.Transactions.Count; i++)
{
if (block.Transactions[i].HasWitness)
{
this.logger.LogTrace("(-)[UNEXPECTED_WITNESS]");
ConsensusErrors.UnexpectedWitness.Throw();
}
}
}
// After the coinbase witness nonce and commitment are verified,
// we can check if the block weight passes (before we've checked the
// coinbase witness, it would be possible for the weight to be too
// large by filling up the coinbase witness, which doesn't change
// the block hash, so we couldn't mark the block as permanently
// failed).
if (this.GetBlockWeight(block) > this.consensusOptions.MaxBlockWeight)
{
this.logger.LogTrace("(-)[BAD_BLOCK_WEIGHT]");
ConsensusErrors.BadBlockWeight.Throw();
}
this.logger.LogTrace("(-)[OK]");
}
public PlayerBot(string n, Level l, ushort x, ushort y, ushort z, byte rotx, byte roty)
{
name = n;
color = "&1";
id = FreeId();
level = l;
pos = new ushort[3] {
x, y, z
}; rot = new byte[2] {
rotx, roty
};
GlobalSpawn();
foreach (Player p in Player.players)
{
if (p.level == level)
{
Player.SendMessage(p, color + name + Server.DefaultColor + ", the bot, has been added.");
}
}
botTimer.Elapsed += delegate
{
int currentNum, foundNum = (32 * 75);
Random rand = new Random();
x = (ushort)Math.Round((decimal)pos[0] / (decimal)32);
y = (ushort)((pos[1] - 33) / 32);
z = (ushort)Math.Round((decimal)pos[2] / (decimal)32);
if (kill)
{
foreach (Player p in Player.players)
{
if ((ushort)(p.pos[0] / 32) == x)
{
if (Math.Abs((ushort)(p.pos[1] / 32) - y) < 2)
{
if ((ushort)(p.pos[2] / 32) == z)
{
p.HandleDeath(Block.Zero);
}
}
}
}
}
if (Waypoints.Count < 1)
{
if (hunt)
{
Player.players.ForEach(delegate(Player p)
{
if (p.level == level && !p.invincible)
{
currentNum = Math.Abs(p.pos[0] - pos[0]) + Math.Abs(p.pos[1] - pos[1]) + Math.Abs(p.pos[2] - pos[2]);
if (currentNum < foundNum)
{
foundNum = currentNum;
foundPos = p.pos;
foundRot = p.rot;
movement = true;
rot[1] = (byte)(255 - foundRot[1]);
if (foundRot[0] < 128)
{
rot[0] = (byte)(foundRot[0] + 128);
}
else
{
rot[0] = (byte)(foundRot[0] - 128);
}
}
}
});
}
}
else
{
bool skip = false;
movement = false;
retry : switch (Waypoints[currentPoint].type)
{
case "walk" :
foundPos[0] = Waypoints[currentPoint].x;
foundPos[1] = Waypoints[currentPoint].y;
foundPos[2] = Waypoints[currentPoint].z;
movement = true;
if ((ushort)(pos[0] / 32) == (ushort)(Waypoints[currentPoint].x / 32))
{
if ((ushort)(pos[2] / 32) == (ushort)(Waypoints[currentPoint].z / 32))
{
rot[0] = Waypoints[currentPoint].rotx;
rot[1] = Waypoints[currentPoint].roty;
currentPoint++;
movement = false;
if (currentPoint == Waypoints.Count)
{
currentPoint = 0;
}
if (!skip)
{
skip = true; goto retry;
}
}
}
break;
case "teleport":
pos[0] = Waypoints[currentPoint].x;
pos[1] = Waypoints[currentPoint].y;
pos[2] = Waypoints[currentPoint].z;
rot[0] = Waypoints[currentPoint].rotx;
rot[1] = Waypoints[currentPoint].roty;
currentPoint++;
if (currentPoint == Waypoints.Count)
{
currentPoint = 0;
}
return;
case "wait":
if (countdown != 0)
{
countdown--;
if (countdown == 0)
{
currentPoint++;
if (currentPoint == Waypoints.Count)
{
currentPoint = 0;
}
if (!skip)
{
skip = true; goto retry;
}
}
}
else
{
countdown = Waypoints[currentPoint].seconds;
}
return;
case "nod":
if (countdown != 0)
{
countdown--;
if (nodUp)
{
if (rot[1] > 32 && rot[1] < 128)
{
nodUp = !nodUp;
}
else
{
if (rot[1] + (byte)Waypoints[currentPoint].rotspeed > 255)
{
rot[1] = 0;
}
else
{
rot[1] += (byte)Waypoints[currentPoint].rotspeed;
}
}
}
else
{
if (rot[1] > 128 && rot[1] < 224)
{
nodUp = !nodUp;
}
else
{
if (rot[1] - (byte)Waypoints[currentPoint].rotspeed < 0)
{
rot[1] = 255;
}
else
{
rot[1] -= (byte)Waypoints[currentPoint].rotspeed;
}
}
}
if (countdown == 0)
{
currentPoint++;
if (currentPoint == Waypoints.Count)
{
currentPoint = 0;
}
if (!skip)
{
skip = true; goto retry;
}
}
}
else
{
countdown = Waypoints[currentPoint].seconds;
}
return;
case "spin":
if (countdown != 0)
{
countdown--;
if (rot[0] + (byte)Waypoints[currentPoint].rotspeed > 255)
{
rot[0] = 0;
}
else if (rot[0] + (byte)Waypoints[currentPoint].rotspeed < 0)
{
rot[0] = 255;
}
else
{
rot[0] += (byte)Waypoints[currentPoint].rotspeed;
}
if (countdown == 0)
{
currentPoint++;
if (currentPoint == Waypoints.Count)
{
currentPoint = 0;
}
if (!skip)
{
skip = true; goto retry;
}
}
}
else
{
countdown = Waypoints[currentPoint].seconds;
}
return;
case "speed":
movementSpeed = (int)Math.Round((decimal)((decimal)24 / (decimal)100 * (decimal)Waypoints[currentPoint].seconds));
if (movementSpeed == 0)
{
movementSpeed = 1;
}
currentPoint++;
if (currentPoint == Waypoints.Count)
{
currentPoint = 0;
}
if (!skip)
{
skip = true; goto retry;
}
return;
case "reset":
currentPoint = 0;
return;
case "remove":
removeBot();
return;
case "linkscript":
if (File.Exists("bots/" + Waypoints[currentPoint].newscript))
{
Command.all.Find("botset").Use(null, this.name + " " + Waypoints[currentPoint].newscript);
return;
}
currentPoint++;
if (currentPoint == Waypoints.Count)
{
currentPoint = 0;
}
if (!skip)
{
skip = true; goto retry;
}
return;
case "jump":
jumpTimer.Elapsed += delegate
{
currentjump++;
switch (currentjump)
{
case 1:
case 2: pos[1] += 24; break;
case 3: break;
case 4: pos[1] -= 24; break;
case 5: pos[1] -= 24; jumping = false; currentjump = 0; jumpTimer.Stop(); break;
}
};
jumpTimer.Start();
currentPoint++;
if (currentPoint == Waypoints.Count)
{
currentPoint = 0;
}
if (!skip)
{
skip = true; goto retry;
}
break;
}
if (currentPoint == Waypoints.Count)
{
currentPoint = 0;
}
}
if (!movement)
{
if (rot[0] < 245)
{
rot[0] += 8;
}
else
{
rot[0] = 0;
}
if (rot[1] > 32 && rot[1] < 64)
{
rot[1] = 224;
}
else if (rot[1] > 250)
{
rot[1] = 0;
}
else
{
rot[1] += 4;
}
}
};
botTimer.Start();
moveTimer.Elapsed += delegate
{
moveTimer.Interval = Server.updateTimer.Interval / movementSpeed;
if (!movement)
{
return;
}
int newNum; Random rand = new Random();
if ((pos[1] - 19) % 32 != 0 && !jumping)
{
pos[1] = (ushort)((pos[1] + 19) - (pos[1] % 32));
}
x = (ushort)Math.Round((decimal)(pos[0] - 16) / (decimal)32);
y = (ushort)((pos[1] - 64) / 32);
z = (ushort)Math.Round((decimal)(pos[2] - 16) / (decimal)32);
byte b = Block.Convert(level.GetTile(x, y, z));
byte b1, b2, b3;//, b4;
if (Block.Walkthrough(b) && !jumping)
{
pos[1] = (ushort)(pos[1] - 32);
}
y = (ushort)((pos[1] - 64) / 32); //Block below feet
newNum = level.PosToInt((ushort)(x + Math.Sign(foundPos[0] - pos[0])), y, (ushort)(z + Math.Sign(foundPos[2] - pos[2])));
b = Block.Convert(level.GetTile(newNum));
b1 = Block.Convert(level.GetTile(level.IntOffset(newNum, 0, 1, 0)));
b2 = Block.Convert(level.GetTile(level.IntOffset(newNum, 0, 2, 0)));
b3 = Block.Convert(level.GetTile(level.IntOffset(newNum, 0, 3, 0)));
if (Block.Walkthrough(b2) && Block.Walkthrough(b3) && !Block.Walkthrough(b1))
{ //Get ready to go up step
pos[0] += (ushort)Math.Sign(foundPos[0] - pos[0]);
pos[1] += (ushort)32;
pos[2] += (ushort)Math.Sign(foundPos[2] - pos[2]);
}
else if (Block.Walkthrough(b1) && Block.Walkthrough(b2))
{ //Stay on current level
pos[0] += (ushort)Math.Sign(foundPos[0] - pos[0]);
pos[2] += (ushort)Math.Sign(foundPos[2] - pos[2]);
}
else if (Block.Walkthrough(b) && Block.Walkthrough(b1))
{ //Drop a level
pos[0] += (ushort)Math.Sign(foundPos[0] - pos[0]);
pos[1] -= (ushort)32;
pos[2] += (ushort)Math.Sign(foundPos[2] - pos[2]);
}
x = (ushort)Math.Round((decimal)(pos[0] - 16) / (decimal)32);
y = (ushort)((pos[1] - 64) / 32);
z = (ushort)Math.Round((decimal)(pos[2] - 16) / (decimal)32);
b1 = Block.Convert(level.GetTile(x, (ushort)(y + 1), z));
b2 = Block.Convert(level.GetTile(x, (ushort)(y + 2), z));
b3 = Block.Convert(level.GetTile(x, y, z));
/*
* if ((ushort)(foundPos[1] / 32) > y) {
* if (b1 == Block.water || b1 == Block.waterstill || b1 == Block.lava || b1 == Block.lavastill) {
* if (Block.Walkthrough(b2)) {
* pos[1] = (ushort)(pos[1] + (Math.Sign(foundPos[1] - pos[1])));
* }
* } else if (b2 == Block.water || b2 == Block.waterstill || b2 == Block.lava || b2 == Block.lavastill) {
* pos[1] = (ushort)(pos[1] + (Math.Sign(foundPos[1] - pos[1])));
* }
* } else if ((ushort)(foundPos[1] / 32) < y) {
* if (b3 == Block.water || b3 == Block.waterstill || b3 == Block.lava || b3 == Block.lavastill) {
* pos[1] = (ushort)(pos[1] + (Math.Sign(foundPos[1] - pos[1])));
* }
* }*/
};
moveTimer.Start();
}
public void PersistBlock(Block blockToPersist, bool shouldHandleTriplesBeforePersisting)
{
HashSet <Triple> blockHeaderTriplesToPersist = new HashSet <Triple>();
BlockHeader blockHeader = blockToPersist.BlockHeader;
BlockContent blockContent = blockToPersist.BlockContent;
Iri blockIri = new Iri(blockToPersist.BlockIri);
blockHeaderTriplesToPersist.Add(new Triple(
blockIri,
RDF.type,
GCO.Block
));
if (blockToPersist.IsGenesisBlock)
{
blockHeaderTriplesToPersist.Add(new Triple(
blockIri,
RDF.type,
GCO.GenesisBlock
));
}
blockHeaderTriplesToPersist.Add(new Triple(
blockIri,
RDF.type,
OWL.NamedIndividual
));
blockHeaderTriplesToPersist.Add(new Triple(
blockIri,
GCO.hasDataGraphIri,
new Literal(blockHeader.DataGraphIri, XMLSchema.AnyURI)
));
blockHeaderTriplesToPersist.Add(new Triple(
blockIri,
GCO.hasDataHash,
new Literal(blockHeader.DataHash)
));
blockHeaderTriplesToPersist.Add(new Triple(
blockIri,
GCO.hasHash,
new Literal(blockHeader.Hash)
));
blockHeaderTriplesToPersist.Add(new Triple(
blockIri,
GCO.hasIndex,
new Literal(blockHeader.Index, XMLSchema.Decimal)
));
blockHeaderTriplesToPersist.Add(new Triple(
blockIri,
GCO.hasPreviousBlock,
new Iri(blockHeader.PreviousBlock)
));
blockHeaderTriplesToPersist.Add(new Triple(
blockIri,
GCO.hasPreviousHash,
new Literal(blockHeader.PreviousHash)
));
blockHeaderTriplesToPersist.Add(new Triple(
blockIri,
GCO.hasTimeStamp,
new Literal(blockHeader.Timestamp, XMLSchema.Decimal)
));
HashSet <Triple> blockContentTriplesToPersist;
if (shouldHandleTriplesBeforePersisting)
{
blockContentTriplesToPersist = _hashingService.HandleTriplesBeforePersisting(blockContent.Triples);
}
else
{
blockContentTriplesToPersist = blockContent.Triples;
}
// TODO: The following invocations should be in the same transaction.
_repository.PersistTriples(_chainGraphIri, blockHeaderTriplesToPersist);
_repository.PersistTriples(blockContent.DataGraphIri, blockContentTriplesToPersist);
}
public virtual void CheckBlock(ContextInformation context)
{
this.logger.LogTrace("()");
Block block = context.BlockResult.Block;
bool mutated = false;
uint256 hashMerkleRoot2 = this.BlockMerkleRoot(block, ref mutated);
if (context.CheckMerkleRoot && (block.Header.HashMerkleRoot != hashMerkleRoot2))
{
this.logger.LogTrace("(-)[BAD_MERKLE_ROOT]");
ConsensusErrors.BadMerkleRoot.Throw();
}
// Check for merkle tree malleability (CVE-2012-2459): repeating sequences
// of transactions in a block without affecting the merkle root of a block,
// while still invalidating it.
if (mutated)
{
this.logger.LogTrace("(-)[BAD_TX_DUP]");
ConsensusErrors.BadTransactionDuplicate.Throw();
}
// All potential-corruption validation must be done before we do any
// transaction validation, as otherwise we may mark the header as invalid
// because we receive the wrong transactions for it.
// Note that witness malleability is checked in ContextualCheckBlock, so no
// checks that use witness data may be performed here.
// Size limits.
if ((block.Transactions.Count == 0) || (block.Transactions.Count > this.consensusOptions.MaxBlockBaseSize) || (this.GetSize(block, TransactionOptions.None) > this.consensusOptions.MaxBlockBaseSize))
{
this.logger.LogTrace("(-)[BAD_BLOCK_LEN]");
ConsensusErrors.BadBlockLength.Throw();
}
// First transaction must be coinbase, the rest must not be
if ((block.Transactions.Count == 0) || !block.Transactions[0].IsCoinBase)
{
this.logger.LogTrace("(-)[NO_COINBASE]");
ConsensusErrors.BadCoinbaseMissing.Throw();
}
for (int i = 1; i < block.Transactions.Count; i++)
{
if (block.Transactions[i].IsCoinBase)
{
this.logger.LogTrace("(-)[MULTIPLE_COINBASE]");
ConsensusErrors.BadMultipleCoinbase.Throw();
}
}
// Check transactions
foreach (Transaction tx in block.Transactions)
{
this.CheckTransaction(tx);
}
long nSigOps = 0;
foreach (Transaction tx in block.Transactions)
{
nSigOps += this.GetLegacySigOpCount(tx);
}
if ((nSigOps * this.consensusOptions.WitnessScaleFactor) > this.consensusOptions.MaxBlockSigopsCost)
{
this.logger.LogTrace("(-)[BAD_BLOCK_SIGOPS]");
ConsensusErrors.BadBlockSigOps.Throw();
}
this.logger.LogTrace("(-)[OK]");
}
