TbBool load_column_file(LevelNumber lv_num)
{
unsigned long i;
long k;
unsigned short n;
long total;
unsigned char *buf;
long fsize;
if ((game.operation_flags & GOF_ColumnConvert) != 0)
{
convert_old_column_file(lv_num);
game.operation_flags &= ~GOF_ColumnConvert;
}
fsize = 8;
buf = load_single_map_file_to_buffer(lv_num,"clm",&fsize,LMFF_None);
if (buf == NULL)
return false;
clear_columns();
i = 0;
total = llong(&buf[i]);
i += 4;
// Validate total amount of columns
if ((total < 0) || (total > (fsize-8)/sizeof(struct Column)))
{
total = (fsize-8)/sizeof(struct Column);
WARNMSG("Bad amount of columns in CLM file; corrected to %ld.",total);
}
if (total > COLUMNS_COUNT)
{
WARNMSG("Only %d columns supported, CLM file has %ld.",COLUMNS_COUNT,total);
total = COLUMNS_COUNT;
}
// Read and validate second amount
game.field_14AB3F = llong(&buf[i]);
if (game.field_14AB3F >= COLUMNS_COUNT)
{
game.field_14AB3F = COLUMNS_COUNT-1;
}
i += 4;
// Fill the columns
for (k=0; k < total; k++)
{
struct Column *colmn;
colmn = &game.columns_data[k];
LbMemoryCopy(colmn, &buf[i], sizeof(struct Column));
//Update top cube in the column
n = find_column_height(colmn);
set_column_floor_filled_subtiles(colmn, n);
i += sizeof(struct Column);
}
LbMemoryFree(buf);
return true;
}
void MockWritableStore::update(llong id, fstring row, DbContext* ctx) {
assert(id >= 0);
assert(id <= llong(m_rows.size()));
if (llong(m_rows.size()) == id) {
append(row, ctx);
return;
}
SpinRwLock lock(m_rwMutex, true);
size_t oldsize = m_rows[id].size();
m_rows[id].assign(row);
m_dataSize -= oldsize;
m_dataSize += row.size();
}
TbBool load_slabclm_file(struct Column *cols, long *ccount)
{
long total;
unsigned char *buf;
long fsize;
long i,k;
SYNCDBG(18,"Starting");
fsize = 4;
buf = load_data_file_to_buffer(&fsize, FGrp_StdData, "slabs.clm");
if (buf == NULL)
return false;
i = 0;
total = llong(&buf[i]);
i += 4;
// Validate total amount of columns
if ((total < 0) || (total > (fsize-4)/sizeof(struct Column)))
{
total = (fsize-4)/sizeof(struct Column);
WARNMSG("Bad amount of columns in Column Set file; corrected to %ld.",total);
}
if (total > *ccount)
{
WARNMSG("Only %d columns supported, Column Set file has %ld.",*ccount,total);
total = *ccount;
}
for (k=0; k < total; k++)
{
LbMemoryCopy(&cols[k],&buf[i],sizeof(struct Column));
i += sizeof(struct Column);
}
*ccount = total;
LbMemoryFree(buf);
return true;
}
void MockReadonlyStore::build(const Schema& schema, SortableStrVec& data) {
size_t fixlen = schema.getFixedRowLen();
if (0 == fixlen) {
if (data.str_size() >= UINT32_MAX) {
THROW_STD(length_error,
"keys.str_size=%lld is too large", llong(data.str_size()));
}
// reuse memory of keys.m_index
auto offsets = (uint32_t*)data.m_index.data();
size_t rows = data.m_index.size();
for (size_t i = 0; i < rows; ++i) {
uint32_t offset = uint32_t(data.m_index[i].offset);
offsets[i] = offset;
}
offsets[rows] = data.str_size();
BOOST_STATIC_ASSERT(sizeof(SortableStrVec::SEntry) == 4*3);
m_rows.offsets.risk_set_data(offsets);
m_rows.offsets.risk_set_size(rows + 1);
m_rows.offsets.risk_set_capacity(3 * rows);
m_rows.offsets.shrink_to_fit();
data.m_index.risk_release_ownership();
#if !defined(NDEBUG)
assert(data.m_strpool.size() == m_rows.offsets.back());
for (size_t i = 0; i < rows; ++i) {
assert(m_rows.offsets[i] < m_rows.offsets[i+1]);
}
#endif
}
m_rows.strpool.swap((valvec<char>&)data.m_strpool);
m_fixedLen = fixlen;
}
void
MockWritableSegment::getValueAppend(llong id, valvec<byte>* val,
DbContext*)
const {
assert(id >= 0);
assert(id < llong(m_rows.size()));
val->append(m_rows[id]);
}
void MockWritableSegment::replace(llong id, fstring row, DbContext*) {
assert(id >= 0);
assert(id < llong(m_rows.size()));
size_t oldsize = m_rows[id].size();
m_rows[id].assign(row);
m_dataSize -= oldsize;
m_dataSize += row.size();
}
void MockWritableSegment::remove(llong id, DbContext*) {
assert(id >= 0);
assert(id < llong(m_rows.size()));
if (m_rows.size()-1 == size_t(id)) {
m_rows.pop_back();
}
else {
m_dataSize -= m_rows[id].size();
m_rows[id].clear();
}
}
void MockWritableStore::remove(llong id, DbContext*) {
assert(id >= 0);
assert(id < llong(m_rows.size()));
SpinRwLock lock(m_rwMutex, true);
if (m_rows.size()-1 == size_t(id)) {
m_rows.pop_back();
}
else {
m_dataSize -= m_rows[id].size();
m_rows[id].clear();
}
}
void
MockReadonlyIndex::build(SortableStrVec& keys) {
const Schema* schema = m_schema;
const byte* base = keys.m_strpool.data();
size_t fixlen = schema->getFixedRowLen();
if (fixlen) {
assert(keys.m_index.size() == 0);
assert(keys.str_size() % fixlen == 0);
m_ids.resize_no_init(keys.str_size() / fixlen);
for (size_t i = 0; i < m_ids.size(); ++i) m_ids[i] = i;
std::sort(m_ids.begin(), m_ids.end(), [=](size_t x, size_t y) {
fstring xs(base + fixlen * x, fixlen);
fstring ys(base + fixlen * y, fixlen);
int r = schema->compareData(xs, ys);
if (r) return r < 0;
else return x < y;
});
}
else {
if (keys.str_size() >= UINT32_MAX) {
THROW_STD(length_error,
"keys.str_size=%lld is too large", llong(keys.str_size()));
}
// reuse memory of keys.m_index
auto offsets = (uint32_t*)keys.m_index.data();
size_t rows = keys.m_index.size();
m_ids.resize_no_init(rows);
for (size_t i = 0; i < rows; ++i) m_ids[i] = i;
for (size_t i = 0; i < rows; ++i) {
uint32_t offset = uint32_t(keys.m_index[i].offset);
offsets[i] = offset;
}
offsets[rows] = keys.str_size();
std::sort(m_ids.begin(), m_ids.end(), [=](size_t x, size_t y) {
size_t xoff0 = offsets[x], xoff1 = offsets[x+1];
size_t yoff0 = offsets[y], yoff1 = offsets[y+1];
fstring xs(base + xoff0, xoff1 - xoff0);
fstring ys(base + yoff0, yoff1 - yoff0);
int r = schema->compareData(xs, ys);
if (r) return r < 0;
else return x < y;
});
BOOST_STATIC_ASSERT(sizeof(SortableStrVec::SEntry) == 4*3);
m_keys.offsets.risk_set_data(offsets);
m_keys.offsets.risk_set_size(rows + 1);
m_keys.offsets.risk_set_capacity(3 * rows);
m_keys.offsets.shrink_to_fit();
keys.m_index.risk_release_ownership();
}
m_keys.strpool.swap((valvec<char>&)keys.m_strpool);
m_fixedLen = fixlen;
}
bool seekExact(llong id, valvec<byte>* val) override {
auto store = static_cast<WrStore*>(m_store.get());
SpinRwLock lock(store->m_rwMutex, false);
if (id < 0 || id >= llong(store->m_rows.size())) {
THROW_STD(out_of_range, "Invalid id = %lld, rows = %zd"
, id, store->m_rows.size());
}
if (!store->m_rows[id].empty()) {
*val = store->m_rows[id];
m_id = id;
return true;
}
return false;
}
bool SeqNumIndex<Int>::insert(fstring key, llong id, DbContext*) {
assert(key.size() == sizeof(Int));
assert(id >= 0);
if (key.size() != sizeof(Int)) {
THROW_STD(invalid_argument,
"key.size must be sizeof(Int)=%d", int(sizeof(Int)));
}
Int keyId = unaligned_load<Int>(key.udata());
if (keyId != m_min + id) {
THROW_STD(invalid_argument,
"key must be consistent with id in SeqNumIndex");
}
if (llong(m_cnt) < id + 1) {
m_cnt = id + 1;
}
return 1;
}
void
MockReadonlyIndex::getValueAppend(llong id, valvec<byte>* key, DbContext*)
const {
assert(id < (llong)m_ids.size());
assert(id >= 0);
if (m_fixedLen) {
assert(m_keys.size() == 0);
assert(0 == llong(m_keys.strpool.size() % m_fixedLen));
assert(m_keys.strpool.size() == m_ids.size() * m_fixedLen);
fstring key1(m_keys.strpool.data() + m_fixedLen * id, m_fixedLen);
key->append(key1.udata(), key1.size());
}
else {
assert(m_ids.size() == m_keys.size());
fstring key1 = m_keys[id];
key->append(key1.udata(), key1.size());
}
}
long load_static_light_file(unsigned long lv_num)
{
unsigned long i;
long k;
long total;
unsigned char *buf;
struct InitLight ilght;
long fsize;
fsize = 4;
buf = load_single_map_file_to_buffer(lv_num,"lgt",&fsize,LMFF_Optional);
if (buf == NULL)
return false;
light_initialise();
i = 0;
total = llong(&buf[i]);
i += 4;
// Validate total amount of lights
if ((total < 0) || (total > (fsize-4)/sizeof(struct InitLight)))
{
total = (fsize-4)/sizeof(struct InitLight);
WARNMSG("Bad amount of static lights in LGT file; corrected to %ld.",total);
}
if (total >= LIGHTS_COUNT)
{
WARNMSG("Only %d static lights supported, LGT file has %ld.",LIGHTS_COUNT,total);
total = LIGHTS_COUNT-1;
} else
if (total >= LIGHTS_COUNT/2)
{
WARNMSG("More than %d%% of light slots used by static lights.",100*total/LIGHTS_COUNT);
}
// Create the lights
for (k=0; k < total; k++)
{
LbMemoryCopy(&ilght, &buf[i], sizeof(struct InitLight));
if (light_create_light(&ilght) == 0)
{
WARNLOG("Couldn't allocate static light %d",(int)k);
}
i += sizeof(struct InitLight);
}
LbMemoryFree(buf);
return true;
}
TbBool load_action_point_file(LevelNumber lv_num)
{
struct InitActionPoint iapt;
unsigned long i;
long k;
long total;
unsigned char *buf;
long fsize;
SYNCDBG(5,"Starting");
fsize = 4;
buf = load_single_map_file_to_buffer(lv_num,"apt",&fsize,LMFF_None);
if (buf == NULL)
return false;
i = 0;
total = llong(&buf[i]);
i += 4;
// Validate total amount of action points
if ((total < 0) || (total > (fsize-4)/sizeof(struct InitActionPoint)))
{
total = (fsize-4)/sizeof(struct InitActionPoint);
WARNMSG("Bad amount of action points in APT file; corrected to %ld.",total);
}
if (total > ACTN_POINTS_COUNT-1)
{
WARNMSG("Only %d action points supported, APT file has %ld.",ACTN_POINTS_COUNT-1,total);
total = ACTN_POINTS_COUNT-1;
}
// Create action points
for (k=0; k < total; k++)
{
LbMemoryCopy(&iapt, &buf[i], sizeof(struct InitActionPoint));
if (actnpoint_create_actnpoint(&iapt) == INVALID_ACTION_POINT)
{
ERRORLOG("Cannot allocate action point %d during APT load",k);
}
i += sizeof(struct InitActionPoint);
}
LbMemoryFree(buf);
return true;
}
void MockWritableStore::remove(llong id, DbContext*) {
assert(id >= 0);
assert(id < llong(m_rows.size()));
m_rows[id].clear();
}
void MockWritableStore::getValueAppend(llong id, valvec<byte>* val, DbContext*) const {
assert(id >= 0);
assert(id < llong(m_rows.size()));
SpinRwLock lock(m_rwMutex, false);
val->append(m_rows[id]);
}
void ScopeScreenView::drawContents(QPainter * p)
{
QRect cr = contentsRect();
for(int i =1; i < m_intervalsX; i++)
{
int x = cr.left() + cr.width()*i/m_intervalsX;
p->drawLine(x, cr.top(), x, cr.bottom());
}
const int ticksPerScreen = m_intervalsX * m_ticksPerIntervalX;
const double pixelsPerTick = cr.width()/double(ticksPerScreen);
const double ticksPerPixel = m_intervalsX * m_ticksPerIntervalX / cr.width();
//draw the current time
int curTimeX = ((Simulator::self()->time() + m_offsetX) % (ticksPerScreen)) * pixelsPerTick;
//kDebug() << curTimeX <<endl;
p->drawLine(curTimeX, cr.top(), curTimeX, cr.bottom());
//the following is liberally borrowed from OscilloscopeView::drawFloatingData
const FloatingProbeDataMap::iterator end = Oscilloscope::self()->m_floatingProbeDataMap.end();
for ( FloatingProbeDataMap::iterator it = Oscilloscope::self()->m_floatingProbeDataMap.begin(); it != end; ++it )
{
FloatingProbeData * probe = it.value();
StoredData<float> * data = &(probe->m_data);
if ( data->allocatedUpTo() == 0 )
continue;
bool logarithmic = probe->scaling() == FloatingProbeData::Logarithmic;
double lowerAbsValue = probe->lowerAbsValue();
double sf = ((cr.height()/Oscilloscope::self()->numberOfProbes())/2) / (logarithmic ? log(probe->upperAbsValue()/lowerAbsValue) : probe->upperAbsValue());
const int midHeight = Oscilloscope::self()->probePositioner->probePosition(probe);
//const int midHeight = cr.top() + cr.height()/2;
//const llong timeOffset = Oscilloscope::self()->scrollTime();
const llong timeOffset = Simulator::self()->time() - (FADESPEED * m_intervalsX * m_ticksPerIntervalX);
// Draw the horizontal line indicating the midpoint of our output
p->setPen( QColor( 228, 228, 228 ) );
p->drawLine( 0, midHeight, width(), midHeight );
// Set the pen colour according to the colour the user has selected for the probe
p->setPen( probe->color() );
llong at = probe->findPos(timeOffset);
const llong maxAt = probe->insertPos();
llong prevTime = probe->toTime(at);
double v = data->dataAt((at>0)?at:0);
int prevY = int(midHeight - (logarithmic ? ( (v>0) ? log(v/lowerAbsValue) : -log(-v/lowerAbsValue) ) : v) * sf);
int prevX = (int((prevTime - timeOffset)*pixelsPerTick) + curTimeX) % cr.width();
while ( at < maxAt-1 )
{
at++;
ullong nextTime = probe->toTime(at);
double v = data->dataAt((at>0)?at:0);
int nextY = int(midHeight - (logarithmic ? ( (v>0) ? log(v/lowerAbsValue) : -log(-v/lowerAbsValue) ) : v) * sf);
int nextX = (int((nextTime - timeOffset)*pixelsPerTick) + curTimeX) % cr.width();
if(nextX < prevX)
{
prevX = 0;
}
//kDebug() <<at<<" "<<nextX<<" "<<nextY<<" "<<nextTime<<endl;
p->drawLine( prevX, prevY, nextX, nextY );
prevTime = nextTime;
prevX = nextX;
prevY = nextY;
//if ( nextX > width() )
//break;
};
// If we could not draw right to the end; it is because we exceeded
// maxAt
//if ( prevX < curTimeX )
// p->drawLine( prevX, prevY, curTimeX, prevY );
}
//and this was liberally borrowed from OscilloscopeView::DrawLogicData
{
const LogicProbeDataMap::iterator end = Oscilloscope::self()->m_logicProbeDataMap.end();
for ( LogicProbeDataMap::iterator it = Oscilloscope::self()->m_logicProbeDataMap.begin(); it != end; ++it )
{
// When searching for the next logic value to display, we look along
// until there is a recorded point which is at least one pixel along
// If we are zoomed out far, there might be thousands of data points
// between each pixel. It is time consuming searching for the next point
// to display one at a time, so we record the average number of data points
// between pixels ( = deltaAt / totalDeltaAt )
llong deltaAt = 1;
int totalDeltaAt = 1;
LogicProbeData * probe = it.value();
StoredData<LogicDataPoint> * data = &(probe->m_data);
if ( data->allocatedUpTo() == 0 )
continue;
const int midHeight = Oscilloscope::self()->probePositioner->probePosition(probe);
const llong timeOffset = Simulator::self()->time() - (FADESPEED * m_intervalsX * m_ticksPerIntervalX);//Oscilloscope::self()->scrollTime();
const int halfOutputHeight = ((cr.height()/Oscilloscope::self()->numberOfProbes())/2);
// Draw the horizontal line indicating the midpoint of our output
p->setPen( QColor( 228, 228, 228 ) );
p->drawLine( 0, midHeight, width(), midHeight );
// Set the pen colour according to the colour the user has selected for the probe
p->setPen( probe->color() );
// The smallest time step that will display in our oscilloscope
const int minTimeStep = ticksPerPixel;//int(LOGIC_UPDATE_RATE/pixelsPerSecond);
llong at = probe->findPos(timeOffset);
const llong maxAt = probe->insertPos();
llong prevTime = data->dataAt(at).time;
int prevX = (int((prevTime - timeOffset)*pixelsPerTick) + curTimeX) % cr.width();
bool prevHigh = data->dataAt(at).value;
int prevY = midHeight + int(prevHigh ? -halfOutputHeight : +halfOutputHeight);
while ( at < maxAt )
{
// Search for the next pos which will show up at our zoom level
llong previousAt = at;
llong dAt = deltaAt / totalDeltaAt;
while ( (dAt > 1) && (at < maxAt) && ( (llong(data->dataAt(at).time) - prevTime) != minTimeStep ) )
{
// Search forwards until we overshoot
while ( at < maxAt && ( llong(data->dataAt(at).time) - prevTime ) < minTimeStep )
at += dAt;
dAt /= 2;
// Search backwards until we undershoot
while ( (at < maxAt) && ( llong(data->dataAt(at).time) - prevTime ) > minTimeStep )
{
at -= dAt;
if ( at < 0 )
at = 0;
}
dAt /= 2;
}
// Possibly increment the value of at found by one (or more if this is the first go)
while ( (previousAt == at) || ((at < maxAt) && ( llong(data->dataAt(at).time) - prevTime ) < minTimeStep) )
at++;
if ( at >= maxAt )
break;
// Update the average values
deltaAt += at - previousAt;
totalDeltaAt++;
bool nextHigh = data->dataAt(at).value;
if ( nextHigh == prevHigh )
continue;
llong nextTime = data->dataAt(at).time;
int nextX = (int((nextTime - timeOffset)*pixelsPerTick) + curTimeX) % cr.width();
int nextY = midHeight + int(nextHigh ? -halfOutputHeight : +halfOutputHeight);
p->drawLine( prevX, prevY, nextX, prevY );
p->drawLine( nextX, prevY, nextX, nextY );
prevHigh = nextHigh;
prevTime = nextTime;
prevX = nextX;
prevY = nextY;
if ( nextX > width() )
break;
};
// If we could not draw right to the end; it is because we exceeded
// maxAt
//if ( prevX < width() )
// p->drawLine( prevX, prevY, width(), prevY );
}
}
}
void getIndexKey(llong* id, valvec<byte>* key, const SeqNumIndex* owner, Int curr) const {
Int keyId = owner->m_min + curr;
*id = llong(curr);
key->erase_all();
key->assign((const byte*)&keyId, sizeof(Int));
}
void MockWritableStore::replace(llong id, fstring row, DbContext*) {
assert(id >= 0);
assert(id < llong(m_rows.size()));
m_rows[id].assign(row);
}