void ReplaceRedeemScript(CScript& script, const CScript& redeemScript)
{
std::vector<valtype> stack;
EvalScript(stack, script, SCRIPT_VERIFY_STRICTENC, BaseSignatureChecker(), SIGVERSION_BASE);
assert(stack.size() > 0);
stack.back() = std::vector<unsigned char>(redeemScript.begin(), redeemScript.end());
script = PushAll(stack);
}
bool ProduceSignature(const SigningProvider& provider, const BaseSignatureCreator& creator, const CScript& fromPubKey, SignatureData& sigdata)
{
if (sigdata.complete) return true;
std::vector<valtype> result;
txnouttype whichType;
bool solved = SignStep(provider, creator, fromPubKey, result, whichType, SigVersion::BASE, sigdata);
bool P2SH = false;
CScript subscript;
sigdata.scriptWitness.stack.clear();
if (solved && whichType == TX_SCRIPTHASH)
{
// Solver returns the subscript that needs to be evaluated;
// the final scriptSig is the signatures from that
// and then the serialized subscript:
subscript = CScript(result[0].begin(), result[0].end());
sigdata.redeem_script = subscript;
solved = solved && SignStep(provider, creator, subscript, result, whichType, SigVersion::BASE, sigdata) && whichType != TX_SCRIPTHASH;
P2SH = true;
}
if (solved && whichType == TX_WITNESS_V0_KEYHASH)
{
CScript witnessscript;
witnessscript << OP_DUP << OP_HASH160 << ToByteVector(result[0]) << OP_EQUALVERIFY << OP_CHECKSIG;
txnouttype subType;
solved = solved && SignStep(provider, creator, witnessscript, result, subType, SigVersion::WITNESS_V0, sigdata);
sigdata.scriptWitness.stack = result;
sigdata.witness = true;
result.clear();
}
else if (solved && whichType == TX_WITNESS_V0_SCRIPTHASH)
{
CScript witnessscript(result[0].begin(), result[0].end());
sigdata.witness_script = witnessscript;
txnouttype subType;
solved = solved && SignStep(provider, creator, witnessscript, result, subType, SigVersion::WITNESS_V0, sigdata) && subType != TX_SCRIPTHASH && subType != TX_WITNESS_V0_SCRIPTHASH && subType != TX_WITNESS_V0_KEYHASH;
result.push_back(std::vector<unsigned char>(witnessscript.begin(), witnessscript.end()));
sigdata.scriptWitness.stack = result;
sigdata.witness = true;
result.clear();
} else if (solved && whichType == TX_WITNESS_UNKNOWN) {
sigdata.witness = true;
}
if (P2SH) {
result.push_back(std::vector<unsigned char>(subscript.begin(), subscript.end()));
}
sigdata.scriptSig = PushAll(result);
// Test solution
sigdata.complete = solved && VerifyScript(sigdata.scriptSig, fromPubKey, &sigdata.scriptWitness, STANDARD_SCRIPT_VERIFY_FLAGS, creator.Checker());
return sigdata.complete;
}
/*
* WriteMem - write some memory, using toolhelp or wdebug.386
*/
DWORD WriteMem( WORD sel, DWORD off, LPVOID buff, DWORD size )
{
DWORD rc;
if( WDebug386 ) {
return( CopyMemory386( sel, off, FP_SEG( buff ), FP_OFF( buff ), size ) );
} else {
PushAll();
rc = MemoryWrite( sel, off, buff, size );
PopAll();
return( rc );
}
} /* WriteMem */
inline void StateStackClass::pvtDrawObject(UInt32 operation, ObjectInstance *objInst, const Pmatrix *rot, const Ppoint *pos, const float sx, const float sy, const float sz, const float scale)
{
UInt32 clipFlag;
float MaxLODRange;
static int in = 0;
ShiAssert(objInst);
PushAll();
// Set up our transformations
CompoundTransform(rot,pos);
SetWorld(rot,pos);
if(operation & OP_WARP)
{
Pmatrix tempM;
ShiAssert((sx > 0.0f) && (sx <= 1.0f));
ShiAssert((sy > 0.0f) && (sy <= 1.0f));
ShiAssert((sz > 0.0f) && (sz <= 1.0f));
Pmatrix stretchM = { sx, 0.f, 0.f,
0.f, sy, 0.f,
0.f, 0.f, sz };
tempM = Rotation;
MatrixMult(&tempM,&stretchM,&Rotation);
D3DFrame::Matrix mS,mT;
mT = mW;
mS.InitIdentity();
mS.m[0][0]=sx; mS.m[1][1]=sy; mS.m[2][2]=sz;
mW = mS*mT;
}
if(scale != 1.f)
{
Pmatrix tempM;
Pmatrix scaleM = { scale, 0.f, 0.f,
0.f, scale, 0.f,
0.f, 0.f, scale };
tempM = Rotation;
MatrixMult(&tempM,&scaleM,&Rotation);
D3DFrame::Matrix mS,mT;
mT = mW;
mS.InitIdentity();
mS.m[0][0]=scale; mS.m[1][1]=scale; mS.m[2][2]=scale;
mW = mS*mT;
}
// Store the adjusted range for LOD determinations
LODRange = Xlation.x * LODBiasInv;
// Choose the appropriate LOD of the object to be drawn
CurrentInstance = objInst;
if (objInst->ParentObject)
{
if (g_bSlowButSafe && F4IsBadCodePtr((FARPROC) objInst->ParentObject)) // JB 010220 CTD (too much CPU)
CurrentLOD = 0; // JB 010220 CTD
else // JB 010220 CTD
if (objInst->id < 0 || objInst->id >= TheObjectListLength || objInst->TextureSet < 0) // JB 010705 CTD second try
{
ShiAssert(FALSE);
CurrentLOD = 0;
}
else
CurrentLOD = objInst->ParentObject->ChooseLOD(LODRange,&LODused,&MaxLODRange);
if(CurrentLOD)
{
// Decide if we need clipping, or if the object is totally off screen
clipFlag = CheckBoundingSphereClipping();
// Continue only if some part of the bounding volume is on screen
if (clipFlag != OFF_SCREEN)
{
// Set the jump pointers to turn on/off clipping
if (clipFlag == ON_SCREEN)
{
Transform = TransformNoClip;
DrawPrimJumpTable = DrawPrimNoClipJumpTable;
}
else
{
Transform = TransformWithClip;
DrawPrimJumpTable = DrawPrimWithClipJumpTable;
}
// Choose perspective correction or not
// if ((Xlation.x > CurrentInstance->Radius() * PERSP_CORR_RADIUS_MULTIPLIER) &&
// !(CurrentLOD->flags & ObjectLOD::PERSP_CORR))
// {
// RenderStateTable = RenderStateTableNPC;
// }
// else
// {
RenderStateTable = RenderStateTablePC;
// }
in ++;
if (in == 1)
{
verts = 0;
}
// Draw the object
CurrentLOD->Draw();
// if (in == 1)
// {
// if (verts)
// {
// MonoPrint ("Obj %d:%d %d : %d\n", objInst->id, LODused, (int) MaxLODRange, verts);
// }
// }
in --;
}
}
}
PopAll();
}
