SpellBookView::SpellBookView(ViewManager* gvm) : View(gvm), book(new BookView(6)), combatMode(false)
{
buttons.resize(BUTTON_COUNT);
buttons[PREV_PAGE] = Button::buildSimple("Prev page", 29, 15, LSI(SPELLS, 1));
buttons[NEXT_PAGE] = Button::buildSimple("Next page", 274, 15, LSI(SPELLS, 2));
buttons[PREV_PAGE]->setAction([this]() {
book->prevPage();
buttons[NEXT_PAGE]->show();
buttons[PREV_PAGE]->showIf(book->hasPrevPage());
});
buttons[NEXT_PAGE]->setAction([this]() {
book->nextPage();
buttons[PREV_PAGE]->show();
buttons[NEXT_PAGE]->showIf(book->hasNextPage());
});
addArea((new Clickable(175,165,18,29))->setAction([gvm](){ gvm->closeOverview(); }));
ClickableGrid* spellGrid = new ClickableGrid(topLeftX[0]-2, topLeftY[0]-2, 125, 22, 6, 2, 7, 0);
spellGrid->setCellAction([this](coord_t x, coord_t y, MouseButton bt) {
if (bt == MouseButton::BUTTON_LEFT)
startCast(book->getEntry(x*6 + y));
else
return true;
return true;
});
addArea(spellGrid);
/*
for (u16 k = 0; k < 2; ++k)
for (u16 i = 0; i < 6;++i)
addArea((new Clickable(topLeftX[k]-2,topLeftY[k]+22*i-2,125,22))->setAction([k,i,this](coord_t, coord_t, MouseButton bt){
startCast(book->getEntry(k*6 + i));
}));*/
}
///////////////////////////////////////////
// Dispatches Zone data packets based on the opCode
void EQPacket::dispatchZoneData(const uint8_t *data, size_t len,
uint8_t dir, uint16_t opCode)
{
#ifdef DEBUG_PACKET
debug ("dispatchZoneData()");
#endif /* DEBUG_PACKET */
QString tempStr;
bool unk = true;
switch (opCode)
{
case OP_ClientUpdate: // old PlayerPosCode:
{
#ifdef PACKET_PAYLOAD_SIZE_DIAG
if ((len != sizeof(playerSpawnPosStruct)) &&
(len != sizeof(playerSelfPosStruct)))
{
fprintf(stderr, "WARNING: OP_ClientUpdate (%04x) (dataLen: %d != sizeof(playerSpawnPosStruct):%d or sizeof(playerSpawnSelfStruct):%d)\n",
OP_ClientUpdate, len,
sizeof(playerSpawnPosStruct), sizeof(playerSelfPosStruct));
unk = true;
}
else
unk = false;
#else
unk = false;
#endif
if (len == sizeof(playerSpawnPosStruct))
emit playerUpdate((const playerSpawnPosStruct*)data, len, dir);
else if (len == sizeof(playerSelfPosStruct))
emit playerUpdate((const playerSelfPosStruct*)data, len, dir);
else
unk = true;
break;
}
case OP_MobUpdate: // old MobUpdateCode:
{
unk = ! ValidatePayload(OP_MobUpdate, spawnPositionUpdate);
emit updateSpawns((const spawnPositionUpdate *)data, len, dir);
break;
}
case OP_WearChange: // old SpawnUpdateCode:
{
unk = ! ValidatePayload(OP_WearChange, SpawnUpdateStruct);
SpawnUpdateStruct *su = (SpawnUpdateStruct*)data;
// printf("SpawnUpdateCode(id=%d, sub=%d, arg1=%d, arg2=%d)\n",
// su->spawnId, su->subcommand,
// su->arg1, su->arg2);
/* Belith - I believe this is depreciated no? Doesn't work anyway ;) */
switch(su->subcommand) {
case 17:
emit updateSpawnMaxHP(su, len, dir);
break;
}
break;
emit updateSpawnInfo(su, len, dir);
}
case OP_SpawnAppearance: // old SpawnAppearanceCode:
{
unk = false;
emit spawnAppearance((const spawnAppearanceStruct*)data, len, dir);
break;
}
case OP_CommonMessage: // old ChannelMessageCode:
{
unk = false;
emit channelMessage((const channelMessageStruct*)data, len, dir);
break;
}
case OP_FormattedMessage: // old FormattedMessageCode:
{
unk = false;
emit formattedMessage((const formattedMessageStruct*)data, len, dir);
break;
}
case OP_SimpleMessage: // old SimpleMessageCode:
{
unk = false;
emit simpleMessage((const simpleMessageStruct*)data, len, dir);
break;
}
case OP_SpecialMesg:
{
unk = false;
emit specialMessage((const specialMessageStruct*)data, len, dir);
break;
}
case OP_GuildMOTD:
{
unk = false;
emit guildMOTD((const guildMOTDStruct*)data, len, dir);
break;
}
case OP_Death: // old NewCorpseCode:
{
unk = ! ValidatePayload(OP_Death, newCorpseStruct);
emit killSpawn((const newCorpseStruct*) data, len, dir);
break;
} /* end CorpseCode */
case OP_DeleteSpawn: // old DeleteSpawnCode:
{
unk = ! ValidatePayload(OP_DeleteSpawn, deleteSpawnStruct);
emit deleteSpawn((const deleteSpawnStruct*)data, len, dir);
break;
}
case OP_ItemLinkResponse: // old ItemInfoCode:
{
unk = false;
if (dir == DIR_SERVER)
emit itemInfo((const itemInfoStruct*)data, len, dir);
else
emit itemInfoReq((const itemInfoReqStruct*)data, len, dir);
}
case OP_ItemPacket: // old ItemCode:
{
unk = false;
if (dir == DIR_SERVER)
emit item((const itemPacketStruct*)data, len, dir);
break;
}
case OP_ItemPlayerPacket:
{
unk = false;
if (dir == DIR_SERVER)
emit playerItem((const char*)data, len, dir);
break;
}
case OP_NewSpawn: // old NewSpawnCode:
{
unk = ! ValidatePayload(OP_NewSpawn, newSpawnStruct);
emit newSpawn((const newSpawnStruct*)data, len, dir);
break;
}
case OP_ItemTextFile: // old BookTextCode:
{
unk = false;
printf("BOOK: '%s'\n", ((const bookTextStruct *)data)->text);
emit bookText((const bookTextStruct*)data, len, dir);
break;
}
case OP_MoneyOnCorpse: // old MoneyOnCorpseCode:
{
unk = ! ValidatePayload(OP_MoneyOnCorpse, moneyOnCorpseStruct);
emit moneyOnCorpse((const moneyOnCorpseStruct*)data, len, dir);
break;
} /* end MoneyOnCorpseCode */
case OP_RandomReply: // old RandomCode:
{
unk = ! ValidatePayload(OP_RandomReply, randomStruct);
emit random((const randomStruct*)data, len, dir);
break;
}
case OP_RandomReq: // RandomReqCode:
{
unk = ! ValidatePayload(OP_RandomReq, randomReqStruct);
emit random((const randomReqStruct*)data, len, dir);
break;
}
case OP_Emote: // old EmoteEmoteTextCode:
{
unk = false;
emit emoteText((const emoteTextStruct*)data, len, dir);
break;
}
case OP_CorpseLocResponse: // old CorpseLocCode:
{
unk = ! ValidatePayload(OP_CorpseLocResponse, corpseLocStruct);
emit corpseLoc((const corpseLocStruct*)data, len, dir);
break;
}
case OP_InspectAnswer: // old InspectDataCode:
{
unk = ! ValidatePayload(OP_InspectAnswer, inspectDataStruct);
emit inspectData((const inspectDataStruct *)data, len, dir);
break;
}
case OP_HPUpdate: // old NpcHpUpdateCode:
{
unk = ! ValidatePayload(OP_HPUpdate, hpNpcUpdateStruct);
emit updateNpcHP((const hpNpcUpdateStruct*)data, len, dir);
break;
}
case SPMesgCode:
{
unk = false;
emit spMessage((const spMesgStruct *)data, len, dir);
break;
}
case OP_MemorizeSpell: // old MemSpellCode:
{
unk = ! ValidatePayload(OP_MemorizeSpell, memSpellStruct);
emit handleSpell((const memSpellStruct*)data, len, dir);
break;
}
case OP_BeginCast: // old BeginCastCode
{
unk = ! ValidatePayload(OP_BeginCast, beginCastStruct);
emit beginCast((const beginCastStruct*)data, len, dir);
break;
}
case OP_CastSpell: // old StartCastCode:
{
unk = ! ValidatePayload(OP_CastSpell, startCastStruct);
emit startCast((const startCastStruct*)data, len, dir);
break;
}
case OP_BuffFadeMsg: // old SpellFadeCode:
{
unk = false;
emit spellFaded((const spellFadedStruct*)data, len, dir);
break;
}
case OP_ExpUpdate: // old ExpUpdateCode:
{
unk = ! ValidatePayload(OP_ExpUpdate, expUpdateStruct);
emit updateExp((const expUpdateStruct*)data, len, dir);
break;
}
case OP_LevelUpdate: // old LevelUpUpdateCode:
{
unk = ! ValidatePayload(OP_LevelUpdate, levelUpUpdateStruct);
emit updateLevel((const levelUpUpdateStruct *)data, len, dir);
break;
}
case OP_SkillUpdate: // old SkillIncCode
{
unk = ! ValidatePayload(OP_SkillUpdate, skillIncStruct);
emit increaseSkill((const skillIncStruct *)data, len, dir);
break;
}
case OP_MoveDoor: // old DoorOpenCode:
{
unk = false;
emit doorOpen(data, len, dir);
break;
}
case OP_Illusion: // old IllusionCode:
{
unk = false;
emit illusion(data, len, dir);
break;
}
case OP_ZoneChange: // old ZoneChangeCode:
{
unk = ! ValidatePayload(OP_ZoneChange, zoneChangeStruct);
// in the process of zoning, server hasn't switched yet.
emit zoneChange((const zoneChangeStruct*)data, len, dir);
break;
}
case OP_ZoneEntry: // old ZoneEntryCode:
{
// We're only interested in the server version
if (dir == DIR_CLIENT)
{
unk = ! ValidatePayload(OP_ZoneEntry, ClientZoneEntryStruct);
emit zoneEntry((const ClientZoneEntryStruct*)data, len, dir);
break;
}
unk = ! ValidatePayload(OP_ZoneEntry, ServerZoneEntryStruct);
emit zoneEntry((const ServerZoneEntryStruct*)data, len, dir);
break;
} /* end ZoneEntryCode */
case OP_NewZone: // old - NewZoneCode:
{
unk = ! ValidatePayload(OP_NewZone, newZoneStruct);
emit zoneNew((const newZoneStruct*)data, len, dir);
if (m_vPacket)
printf("New Zone at byte: %ld\n", m_vPacket->FilePos());
break;
}
case OP_PlayerProfile: // Character Profile server to client - old CharProfileCode
{
unk = false;
ValidatePayload(OP_PlayerProfile, charProfileStruct);
emit backfillPlayer((const charProfileStruct*)data, len, DIR_SERVER);
break;
}
case OP_ZoneSpawns: // ZoneSpawnsCode:
{
unk = false;
emit zoneSpawns((const zoneSpawnsStruct*)data, len, dir);
break;
}
case OP_TimeOfDay: // old TimeOfDayCode:
{
unk = ! ValidatePayload(OP_TimeOfDay, timeOfDayStruct);
emit timeOfDay((const timeOfDayStruct*)data, len, dir);
break;
}
case WearChangeCode:
{
unk = ! ValidatePayload(WearChangeCode, wearChangeStruct);
emit spawnWearingUpdate ((const wearChangeStruct*)data, len, dir);
break;
}
case OP_Action:
{
unk = ! ValidatePayload(OP_Action, actionStruct);
emit action((const actionStruct*)data, len, dir);
break;
}
case OP_CastBuff: // old ActionCode:
{
unk = false;
emit action2Message ((const action2Struct *)data, len, dir);
break;
}
case OP_Stamina: /// old StaminaCode:
{
unk = ! ValidatePayload(OP_Stamina, staminaStruct);
emit updateStamina((const staminaStruct *)data, len, dir);
break;
}
case OP_GroundSpawn: // old MakeDropCode:
{
#ifdef PACKET_PAYLOAD_SIZE_DIAG
if ((len != sizeof(makeDropStruct)) &&
(len != 0))
{
fprintf(stderr, "WARNING: OP_GroundSpawn (%04x) (dataLen: %d != sizeof(makeDropStruct):%d or 0)\n",
OP_GroundSpawn, len,
sizeof(makeDropStruct));
unk = true;
}
else
unk = false;
#else
unk = false;
#endif
emit newGroundItem((const makeDropStruct*)data, len, dir);
break;
}
case OP_ClickObject: // Old RemDropCode:
{
unk = ! ValidatePayload(OP_ClickObject, remDropStruct);
emit removeGroundItem((const remDropStruct *)data, len, dir);
break;
}
case OP_ShopRequest: // old OpenVendorCode:
{
unk = false;
emit openVendor(data, len, dir);
break;
}
case OP_ShopEnd: // old CloseVendorCode:
{
unk = false;
emit closeVendor(data, len, dir);
break;
}
case OP_GMTraining: // old OpenGMCode:
{
unk = false;
emit openGM(data, len, dir);
break;
}
case OP_GMEndTrainingResponse: // old CloseGMCode:
{
unk = false;
emit closeGM(data, len, dir);
break;
}
case OP_Consider: // old ConsiderCode:
{
unk = false;
ValidatePayload(OP_Consider, considerStruct);
emit consMessage((const considerStruct*)data, len, dir);
break;
}
case OP_TargetMouse: // old ClientTargetCode:
{
unk = ! ValidatePayload(OP_TargetMouse, clientTargetStruct);
emit clientTarget((const clientTargetStruct*) data, len, dir);
break;
}
case OP_SpawnDoor: // old DoorSpawnsCode:
{
unk = false;
#ifdef PACKET_PAYLOAD_SIZE_DIAG
// verify size
if (len % sizeof(doorStruct) != 0)
{
printf("WARNING: OP_SpawnDoor (%.04x) (dataLen:%d "
"%% sizeof(doorStruct):%d) != 0!\n",
OP_SpawnDoor, len, sizeof(doorStruct));
unk = true;
break;
}
#endif
int nDoors = len / sizeof(doorStruct);
const DoorSpawnsStruct *doorsStruct = (const DoorSpawnsStruct *)data;
for (int i = 0; i < nDoors; i++) {
emit newDoorSpawn(&doorsStruct->doors[i], len, dir);
}
emit newDoorSpawns(doorsStruct, len, dir);
break;
}
case OP_Buff: // old BuffDropCode:
{
unk = ! ValidatePayload(OP_Buff, buffStruct);
emit buff((const buffStruct*)data, len, dir);
// this is the server 'buff fading' AND the client 'cancel buff'
break;
}
case OP_Logout: // no contents
{
unk = false;
emit logOut(data, len, dir);
break;
}
case OP_SendZonePoints:
{
unk = false;
#ifdef PACKET_PAYLOAD_SIZE_DIAG
const zonePointsStruct* zp = (const zonePointsStruct*)data;
// verify size
if (((len - sizeof(zp->count) - sizeof(zp->unknown0xxx))
% sizeof(zonePointStruct)) != 0)
{
fprintf(stderr, "WARNING: OP_SendZonePoints (%04x) (dataLen: %d %% sizeof(zonePointStruct):%d) != 0!\n",
OP_SendZonePoints, len, sizeof(zonePointStruct));
unk = true;
break;
}
#endif
emit zonePoints((const zonePointsStruct*)data, len, dir);
break;
}
case OP_GuildMemberList: // old GuildMemberListCode
{
unk = false;
break;
}
case OP_GuildMemberUpdate: // old GuildMemberUpdateCode:
{
unk = false;
break;
}
case OP_SetRunMode: // old cRunToggleCode:
{
//unk = ! ValidatePayload(cRunToggleCode, cRunToggleStruct);
//emit cRunToggle((const cRunToggleStruct*)data, len, dir);
unk = false;
break;
}
case OP_Jump: // old cJumpCode:
{
//no data
unk = false;
break;
}
case OP_Camp: // old cStartCampingCode:
{
//no data
unk = false;
break;
}
case OP_SenseHeading: // old cSenseHeadingCode:
{
//no data
unk = false;
break;
}
case OP_Forage: // old ForageCode:
{
//no data
unk = false;
break;
}
#if 0 // ZBTEMP : If we don't bother setting unk, don't bother processing
case OP_ConsiderCorpse: //unknown contents // old cConCorpseCode:
{
//unk = ! ValidatePayload(cConCorpseCode, cConCorpseStruct);
//emit cConCorpse((const cConCorpseStruct*)data, len, dir);
break;
}
case OP_LootRequest: //unknown contents - old cLootCorpseCode
{
//unk = ! ValidatePayload(cLootCorpseCode, cLootCorpseStruct);
//emit cLootCorpse((const cLootCorpseStruct*)data, len, dir);
break;
}
case OP_EndLootRequest: //unknown contents - old cDoneLootingCode
{
//unk = ! ValidatePayload(cDoneLootingCode, cDoneLootingStruct);
//emit cDoneLooting((const cDoneLootingStruct*)data, len, dir);
break;
}
case OP_LootComplete: //unknown contents - old sDoneLootingCode
{
//unk = ! ValidatePayload(sDoneLootingCode, sDoneLootingStruct);
//emit sDoneLooting((const sDoneLootingStruct*)data, len, dir);
break;
}
case OP_WhoAllRequest: //unknown contents - old WhoAllReqCode
{
//unk = ! ValidatePayload(cWhoAllCode, cWhoAllStruct);
//emit cWhoAll((const cWhoAllStruct*)data, len, dir);
break;
}
case OP_WhoAllResponse: // old sWhoAllOutputCode: unknown contents
{
//unk = ! ValidatePayload(sWhoAllOutputCode, sWhoAllOutputStruct);
//emit sWhoAllOutput((const sWhoAllOutputStruct*)data, len, dir);
break;
}
case OP_ShopPlayerBuy: //unknown contents - old BuyItemCode
{
//unk = ! ValidatePayload(xBuyItemCode, xBuyItemStruct);
//emit xBuyItem((const xBuyItemStruct*)data, len, dir);
//both the client command and the server acknowledgement when buying
break;
}
#endif // ZBTEMP
#if 0 // ZBTEMP: OPCode Graveyard
case CastOnCode:
{
unk = false;
emit castOn((castOnStruct*)data, len, dir);
break;
}
case ManaDecrementCode:
{
unk = ! ValidatePayload(ManaDecrementCode, manaDecrementStruct);
emit manaChange((struct manaDecrementStruct *)data, len, dir);
break;
}
case BadCastCode:
{
unk = false; //! ValidatePayload(BadCastCode, badCastStruct);
emit interruptSpellCast((const badCastStruct*)data, len, dir);
break;
}
case SysMsgCode:
{
unk = false;
emit systemMessage((const sysMsgStruct*)data, len, dir);
break;
}
case AltExpUpdateCode:
{
unk = ! ValidatePayload(AltExpUpdateCode, altExpUpdateStruct);
emit updateAltExp((const altExpUpdateStruct*)data, len, dir);
break;
}
case Attack2Code:
{
unk = false;
emit attack2Hand1 ((const attack2Struct *)data, len, dir);
break;
}
case NewGuildInZoneCode:
{
unk = false;
break;
}
case MoneyUpdateCode:
{
unk = false;
emit moneyUpdate((const moneyUpdateStruct*)data, len, dir);
break;
}
case MoneyThingCode:
{
unk = false;
emit moneyThing((const moneyThingStruct*)data, len, dir);
break;
}
case BindWoundCode:
{
unk = false;
emit bindWound((bindWoundStruct*)data, len, dir);
break;
}
case GroupInfoCode:
{
// Too much still unknown.
unk = ! ValidatePayload(GroupInfoCode, groupMemberStruct);
emit groupInfo((const groupMemberStruct*)data, len, dir);
break;
}
case GroupInviteCode:
{
unk = ! ValidatePayload(GroupInviteCode, groupInviteStruct);
emit groupInvite((const groupInviteStruct*)data, len, dir);
break;
}
case GroupDeclineCode:
{
unk = ! ValidatePayload(GroupDeclineCode, groupDeclineStruct);
emit groupDecline((const groupDeclineStruct*)data, len, dir);
break;
}
case GroupAcceptCode:
{
unk = ! ValidatePayload(GroupAcceptCode, groupAcceptStruct);
emit groupAccept((const groupAcceptStruct*)data, len, dir);
break;
}
case GroupDeleteCode:
{
unk = ! ValidatePayload(GroupDeleteCode, groupDeleteStruct);
emit groupDelete((const groupDeleteStruct*)data, len, dir);
break;
}
case CharUpdateCode:
{
break;
}
case cChatFiltersCode:
{
//unk = ! ValidatePayload(cChatFiltersCode, cChatFiltersStruct);
//emit cChatFilters((const cChatFiltersStruct*)data, len, dir);
unk = false;
break;
}
case cOpenSpellBookCode:
{
//unk = ! ValidatePayload(cOpenSpellBookCode, cOpenSpellBookStruct);
//emit cOpenSpellBook((const cOpenSpellBookStruct*)data, len, dir);
unk = false;
break;
}
case OP_SwapSpell: // old TradeSpellBookSlotsCode:
{
unk = ! ValidatePayload(OP_SwapSpell, tradeSpellBookSlotsStruct);
emit tradeSpellBookSlots((const tradeSpellBookSlotsStruct*)data, len, dir);
break;
}
case sSpellFizzleRegainCode: //unknown contents, also comes when you Forage
{
//unk = ! ValidatePayload(sSpellFizzleRegainCode, sSpellFizzleRegainStruct);
//emit sSpellFizzleRegain((const sSpellFizzleRegainStruct*)data, len, dir);
break;
}
case sSpellInterruptedCode: //unknown contents
{
//unk = ! ValidatePayload(sSpellInterruptedCode, sSpellInterruptedStruct);
//emit sSpellInterrupted((const sSpellInterruptedStruct*)data, len, dir);
break;
}
case cHideCode:
{
//no data
unk = false;
break;
}
case cSneakCode:
{
//no data
unk = false;
break;
}
case cTrackCode:
{
//no data
unk = false;
break;
}
#endif // ZBTEMP // Currently dead opcodes
default:
{
}
} /* end switch(opCode) */
emit decodedZonePacket(data, len, dir, opCode, unk);
}
void Item::updatePos(const U32 /*mask*/, const F32 dt)
{
// Try and move
Point3F pos;
mObjToWorld.getColumn(3,&pos);
delta.posVec = pos;
bool contact = false;
bool nonStatic = false;
bool stickyNotify = false;
CollisionList collisionList;
F32 time = dt;
static Polyhedron sBoxPolyhedron;
static ExtrudedPolyList sExtrudedPolyList;
static EarlyOutPolyList sEarlyOutPolyList;
MatrixF collisionMatrix(true);
Point3F end = pos + mVelocity * time;
U32 mask = isServerObject() ? sServerCollisionMask : sClientCollisionMask;
// Part of our speed problem here is that we don't track contact surfaces, like we do
// with the player. In order to handle the most common and performance impacting
// instance of this problem, we'll use a ray cast to detect any contact surfaces below
// us. This won't be perfect, but it only needs to catch a few of these to make a
// big difference. We'll cast from the top center of the bounding box at the tick's
// beginning to the bottom center of the box at the end.
Point3F startCast((mObjBox.minExtents.x + mObjBox.maxExtents.x) * 0.5,
(mObjBox.minExtents.y + mObjBox.maxExtents.y) * 0.5,
mObjBox.maxExtents.z);
Point3F endCast((mObjBox.minExtents.x + mObjBox.maxExtents.x) * 0.5,
(mObjBox.minExtents.y + mObjBox.maxExtents.y) * 0.5,
mObjBox.minExtents.z);
collisionMatrix.setColumn(3, pos);
collisionMatrix.mulP(startCast);
collisionMatrix.setColumn(3, end);
collisionMatrix.mulP(endCast);
RayInfo rinfo;
bool doToughCollision = true;
disableCollision();
if (mCollisionObject)
mCollisionObject->disableCollision();
if (getContainer()->castRay(startCast, endCast, mask, &rinfo))
{
F32 bd = -mDot(mVelocity, rinfo.normal);
if (bd >= 0.0)
{
// Contact!
if (mDataBlock->sticky && rinfo.object->getTypeMask() & (STATIC_COLLISION_TYPEMASK)) {
mVelocity.set(0, 0, 0);
mAtRest = true;
mAtRestCounter = 0;
stickyNotify = true;
mStickyCollisionPos = rinfo.point;
mStickyCollisionNormal = rinfo.normal;
doToughCollision = false;;
} else {
// Subtract out velocity into surface and friction
VectorF fv = mVelocity + rinfo.normal * bd;
F32 fvl = fv.len();
if (fvl) {
F32 ff = bd * mDataBlock->friction;
if (ff < fvl) {
fv *= ff / fvl;
fvl = ff;
}
}
bd *= 1 + mDataBlock->elasticity;
VectorF dv = rinfo.normal * (bd + 0.002);
mVelocity += dv;
mVelocity -= fv;
// Keep track of what we hit
contact = true;
U32 typeMask = rinfo.object->getTypeMask();
if (!(typeMask & StaticObjectType))
nonStatic = true;
if (isServerObject() && (typeMask & ShapeBaseObjectType)) {
ShapeBase* col = static_cast<ShapeBase*>(rinfo.object);
queueCollision(col,mVelocity - col->getVelocity());
}
}
}
}
enableCollision();
if (mCollisionObject)
mCollisionObject->enableCollision();
if (doToughCollision)
{
U32 count;
for (count = 0; count < 3; count++)
{
// Build list from convex states here...
end = pos + mVelocity * time;
collisionMatrix.setColumn(3, end);
Box3F wBox = getObjBox();
collisionMatrix.mul(wBox);
Box3F testBox = wBox;
Point3F oldMin = testBox.minExtents;
Point3F oldMax = testBox.maxExtents;
testBox.minExtents.setMin(oldMin + (mVelocity * time));
testBox.maxExtents.setMin(oldMax + (mVelocity * time));
sEarlyOutPolyList.clear();
sEarlyOutPolyList.mNormal.set(0,0,0);
sEarlyOutPolyList.mPlaneList.setSize(6);
sEarlyOutPolyList.mPlaneList[0].set(wBox.minExtents,VectorF(-1,0,0));
sEarlyOutPolyList.mPlaneList[1].set(wBox.maxExtents,VectorF(0,1,0));
sEarlyOutPolyList.mPlaneList[2].set(wBox.maxExtents,VectorF(1,0,0));
sEarlyOutPolyList.mPlaneList[3].set(wBox.minExtents,VectorF(0,-1,0));
sEarlyOutPolyList.mPlaneList[4].set(wBox.minExtents,VectorF(0,0,-1));
sEarlyOutPolyList.mPlaneList[5].set(wBox.maxExtents,VectorF(0,0,1));
CollisionWorkingList& eorList = mConvex.getWorkingList();
CollisionWorkingList* eopList = eorList.wLink.mNext;
while (eopList != &eorList) {
if ((eopList->mConvex->getObject()->getTypeMask() & mask) != 0)
{
Box3F convexBox = eopList->mConvex->getBoundingBox();
if (testBox.isOverlapped(convexBox))
{
eopList->mConvex->getPolyList(&sEarlyOutPolyList);
if (sEarlyOutPolyList.isEmpty() == false)
break;
}
}
eopList = eopList->wLink.mNext;
}
if (sEarlyOutPolyList.isEmpty())
{
pos = end;
break;
}
collisionMatrix.setColumn(3, pos);
sBoxPolyhedron.buildBox(collisionMatrix, mObjBox, true);
// Build extruded polyList...
VectorF vector = end - pos;
sExtrudedPolyList.extrude(sBoxPolyhedron, vector);
sExtrudedPolyList.setVelocity(mVelocity);
sExtrudedPolyList.setCollisionList(&collisionList);
CollisionWorkingList& rList = mConvex.getWorkingList();
CollisionWorkingList* pList = rList.wLink.mNext;
while (pList != &rList) {
if ((pList->mConvex->getObject()->getTypeMask() & mask) != 0)
{
Box3F convexBox = pList->mConvex->getBoundingBox();
if (testBox.isOverlapped(convexBox))
{
pList->mConvex->getPolyList(&sExtrudedPolyList);
}
}
pList = pList->wLink.mNext;
}
if (collisionList.getTime() < 1.0)
{
// Set to collision point
F32 dt = time * collisionList.getTime();
pos += mVelocity * dt;
time -= dt;
// Pick the most resistant surface
F32 bd = 0;
const Collision* collision = 0;
for (int c = 0; c < collisionList.getCount(); c++) {
const Collision &cp = collisionList[c];
F32 dot = -mDot(mVelocity,cp.normal);
if (dot > bd) {
bd = dot;
collision = &cp;
}
}
if (collision && mDataBlock->sticky && collision->object->getTypeMask() & (STATIC_COLLISION_TYPEMASK)) {
mVelocity.set(0, 0, 0);
mAtRest = true;
mAtRestCounter = 0;
stickyNotify = true;
mStickyCollisionPos = collision->point;
mStickyCollisionNormal = collision->normal;
break;
} else {
// Subtract out velocity into surface and friction
if (collision) {
VectorF fv = mVelocity + collision->normal * bd;
F32 fvl = fv.len();
if (fvl) {
F32 ff = bd * mDataBlock->friction;
if (ff < fvl) {
fv *= ff / fvl;
fvl = ff;
}
}
bd *= 1 + mDataBlock->elasticity;
VectorF dv = collision->normal * (bd + 0.002);
mVelocity += dv;
mVelocity -= fv;
// Keep track of what we hit
contact = true;
U32 typeMask = collision->object->getTypeMask();
if (!(typeMask & StaticObjectType))
nonStatic = true;
if (isServerObject() && (typeMask & ShapeBaseObjectType)) {
ShapeBase* col = static_cast<ShapeBase*>(collision->object);
queueCollision(col,mVelocity - col->getVelocity());
}
}
}
}
else
{
pos = end;
break;
}
}
if (count == 3)
{
// Couldn't move...
mVelocity.set(0, 0, 0);
}
}
// If on the client, calculate delta for backstepping
if (isGhost()) {
delta.pos = pos;
delta.posVec -= pos;
delta.dt = 1;
}
// Update transform
MatrixF mat = mObjToWorld;
mat.setColumn(3,pos);
Parent::setTransform(mat);
enableCollision();
if (mCollisionObject)
mCollisionObject->enableCollision();
updateContainer();
if ( mPhysicsRep )
mPhysicsRep->setTransform( mat );
//
if (contact) {
// Check for rest condition
if (!nonStatic && mVelocity.len() < sAtRestVelocity) {
mVelocity.x = mVelocity.y = mVelocity.z = 0;
mAtRest = true;
mAtRestCounter = 0;
}
// Only update the client if we hit a non-static shape or
// if this is our final rest pos.
if (nonStatic || mAtRest)
setMaskBits(PositionMask);
}
// Collision callbacks. These need to be processed whether we hit
// anything or not.
if (!isGhost())
{
SimObjectPtr<Item> safePtr(this);
if (stickyNotify)
{
notifyCollision();
if(bool(safePtr))
onStickyCollision_callback( getIdString() );
}
else
notifyCollision();
// water
if(bool(safePtr))
{
if(!mInLiquid && mWaterCoverage != 0.0f)
{
mInLiquid = true;
if ( !isGhost() )
mDataBlock->onEnterLiquid_callback( this, mWaterCoverage, mLiquidType.c_str() );
}
else if(mInLiquid && mWaterCoverage == 0.0f)
{
mInLiquid = false;
if ( !isGhost() )
mDataBlock->onLeaveLiquid_callback( this, mLiquidType.c_str() );
}
}
}
}
