void OpenSMOKE_MatrixSparsityPattern::operator ()(const int row, const int col)
{
if (row < 1 || row > rows_ || col < 1 || col > columns_)
{
std::cout << "Matrix size: " << rows_ << " x " << columns_ << std::endl;
std::cout << "Requested element: " << row << " " << col << std::endl;
OpenSMOKE::FatalErrorMessage("MatrixSparsityPattern: the row and column indices of inserted element must fit the matrix dimension");
}
ElementSparsityPattern *elem = element_row_[row];
if (elem == 0 || col < elem->column)
{
InsertElement(elem, row, col, 1);
return;
}
if (col == elem->column)
return;
for (; elem->next != 0; elem = elem->next)
{
if (col == elem->next->column)
return;
else if (col < elem->next->column)
break;
}
InsertElement(elem, row, col, 0);
}
void Screen::ShowDialog(Dialog *pDlg, bool fFade)
{
assert(pDlg);
// do place console mode dialogs
if (Application.isFullScreen || pDlg->IsViewportDialog())
// exclusive or free dlg: center pos
// evaluate own placement proc first
if (!pDlg->DoPlacement(this, PreferredDlgRect))
{
if (pDlg->IsFreePlaceDialog())
pDlg->SetPos((GetWidth() - pDlg->GetWidth()) / 2, (GetHeight() - pDlg->GetHeight()) / 2 + pDlg->IsBottomPlacementDialog()*GetHeight()/3);
else if (IsExclusive())
pDlg->SetPos((GetWidth() - pDlg->GetWidth()) / 2, (GetHeight() - pDlg->GetHeight()) / 2);
else
// non-exclusive mode at preferred viewport pos
pDlg->SetPos(PreferredDlgRect.x+30, PreferredDlgRect.y+30);
}
// add to local component list at correct ordering
int32_t iNewZ = pDlg->GetZOrdering(); Element *pEl; Dialog *pOtherDlg;
for (pEl = GetFirst(); pEl; pEl = pEl->GetNext())
if (pOtherDlg = pEl->GetDlg())
if (pOtherDlg->GetZOrdering() > iNewZ)
break;
InsertElement(pDlg, pEl);
// set as active, if not fading and on top
if (!fFade && !pEl)
// but not viewport dialogs!
if (!pDlg->IsExternalDrawDialog())
pActiveDlg = pDlg;
// show it
pDlg->fOK = false;
pDlg->fShow = true;
// mouse focus might have changed
UpdateMouseFocus();
}
void C4Network2ResDlg::Update()
{
// check through own resources and current res list
ListItem *pItem = static_cast<ListItem *>(pClientWindow->GetFirst()), *pNext;
C4Network2Res *pRes; int iResID=-1;
while ((pRes = ::Network.ResList.getRefNextRes(++iResID)))
{
iResID = pRes->getResID();
// resource checking: deleted resource(s) present?
while (pItem && (pItem->GetResID() < iResID))
{
pNext = static_cast<ListItem *>(pItem->GetNext());
delete pItem; pItem = pNext;
}
// same resource present for update?
if (pItem && pItem->GetResID() == iResID)
{
pItem->Update(pRes);
pItem = static_cast<ListItem *>(pItem->GetNext());
}
else
// not present: insert (or add if pItem=NULL)
InsertElement(new ListItem(this, pRes), pItem);
}
// del trailing items
while (pItem)
{
pNext = static_cast<ListItem *>(pItem->GetNext());
delete pItem; pItem = pNext;
}
}
void SLS_SimpleList ::
InsertAfter( SLSE_ListElementValue * pValueParm )
{
InsertElement( pValueParm , false ) ;
} // End of function: SLS !Insert element after
void SLS_SimpleList ::
InsertBefore( SLSE_ListElementValue * pValueParm )
{
InsertElement( pValueParm , true ) ;
} // End of function: SLS !Insert element before
void PriorityQueue::HeapSort(int array[], int n)
{
for(int i=0;i<n;i++)
InsertElement(array[i]);
for(int i=n-1;i>=0;i--)
array[i] = DeleteTop();
}
KDicomElement * KDicomDS::InsertElement(unsigned short group, unsigned short element)
{
KD_TAG tag;
tag.group = group;
tag.element = element;
return InsertElement(tag);
}
int InsertTileRowElement (ElementList **list, int counter, unsigned short *buff)
{
int i;
for (i=0;i < windowwidth; i++) {
counter += InsertElement (list, (unsigned int) buff[i]);
}
return counter;
}
int InsertTileColElement (ElementList **list, int counter, unsigned short *buff)
{
int i;
for (i=0;i < windowheight; i++) {
counter += InsertElement (list, (unsigned int) *buff);
buff += datawidth;
}
return counter;
}
ALERROR CIntArray::AppendElement (int iElement, int *retiIndex)
// AppendElement
//
// Appends element to the array
{
return InsertElement(iElement, m_iLength, retiIndex);
}
void
GRaggedFloatTableData::DuplicateElement
(
const JIndex row,
const JIndex col
)
{
JFloat value;
if (GetElement(row,col, &value))
{
InsertElement(row, col, value);
}
}
int CreateTileListElement (ElementList **list)
{
int i, j;
int counter = 0;
unsigned short *buff = databuffer;
for (i=0;i < windowheight; i++) {
for (j=0;j < windowwidth; j++) {
counter += InsertElement (list, (unsigned int) buff[j]);
}
buff += datawidth;
}
return counter;
}
void
GRaggedFloatTableData::MoveElement
(
const JIndex origRow,
const JIndex origCol,
const JIndex newRow,
const JIndex newCol
)
{
JFloat value;
if (GetElement(origRow, origCol, &value))
{
InsertElement(newRow, newCol, value);
RemoveElement(origRow, origCol);
}
}
void AddStructureInterface(linkedList *list)
{
char name[256];
char ageBuffer[256];
int age;
printf("Enter name:\n");
fgets(name, 256, stdin);
name[strlen(name) - 1] = '\0';
printf("Enter age:\n");
fgets(ageBuffer, 256, stdin);
sscanf(ageBuffer, "%d", &age);
InsertElement(list, AllocateElement(age, name));
}
int main()
{
int x;
SeqList *p = InitSeqList();
printf("\nPlease input the x：");
while(scanf("%d", &x))
{
InsertElement(p, x); // 插入元素
PrintElements(p); // 再次输出所有元素
printf("\nPlease input the x：");
}
//PrintElements(DeleteRepeatedElement(p)); // 删除重复元素并输出
Delete4(p);
PrintElements(p);
return 0;
}
// this adds an element to the list in an ordered position. The existing must be ordered obviously
// it returns the position in the list that the data was inserted, or 0xFFFFFFFF for a bosh.
unsigned long AddSortedElement(void *dataPtr,Size dataSize,CompareProc sortProc,void *refCon,LinkedList *theList)
{
ElementHandle moo=theList; // the address of a linked list
unsigned long pos=0L;
while (*moo)
{
// if the new data is > the current data, go onto the next element
if (sortProc((Ptr)dataPtr,(Ptr)(**moo).data,refCon)>0)
{
// onto the next element
moo=(ElementHandle)&((**moo).next);
pos++;
}
else
break; // insert the data here
}
if (InsertElement(theList,pos,(Ptr)dataPtr,dataSize))
return pos;
else
return -1L;
}
void
GRaggedFloatTableData::InsertRow
(
const JIndex index,
const JOrderedSet<JFloat>* initData
)
{
assert( initData == NULL || initData->GetElementCount() == GetDataColCount() );
const JSize colCount = itsCols->GetElementCount();
for (JIndex i=1; i<=colCount; i++)
{
JArray<JFloat>* colData = itsCols->NthElement(i);
if (index <= colData->GetElementCount())
{
JFloat value = 0;
if ((initData != NULL) && (i <= initData->GetElementCount()))
{
value = initData->GetElement(i);
}
InsertElement(index, i);
}
}
}
void _SimpleList::operator << (long br)
{
InsertElement ((BaseRef)br, -1, false, false);
}
static void
thraddash_preprocess (ELEMENT *ElementPtr)
{
STARSHIP *StarShipPtr;
GetElementStarShip (ElementPtr, &StarShipPtr);
// Switch side guns after every shot.
if (StarShipPtr->weapon_counter == 1)
{
if (StarShipPtr->static_counter == 0)
++StarShipPtr->static_counter;
else
StarShipPtr->static_counter = 0;
}
if (!(StarShipPtr->cur_status_flags & SPECIAL))
{
if (StarShipPtr->old_status_flags & SPECIAL
&& StarShipPtr->cur_status_flags & SHIP_AT_MAX_SPEED)
StarShipPtr->cur_status_flags |= SHIP_BEYOND_MAX_SPEED;
}
else if (StarShipPtr->RaceDescPtr->ship_info.energy_level >= SPECIAL_ENERGY_COST)
{
COUNT max_thrust, thrust_increment;
STATUS_FLAGS thrust_status;
HELEMENT hTrailElement;
if (!(StarShipPtr->old_status_flags & SPECIAL))
StarShipPtr->cur_status_flags &=
~(SHIP_AT_MAX_SPEED | SHIP_BEYOND_MAX_SPEED);
if (ElementPtr->thrust_wait == 0)
++ElementPtr->thrust_wait;
thrust_increment = StarShipPtr->RaceDescPtr->characteristics.thrust_increment;
max_thrust = StarShipPtr->RaceDescPtr->characteristics.max_thrust;
StarShipPtr->RaceDescPtr->characteristics.thrust_increment = SPECIAL_THRUST_INCREMENT;
StarShipPtr->RaceDescPtr->characteristics.max_thrust = SPECIAL_MAX_THRUST;
thrust_status = inertial_thrust (ElementPtr);
StarShipPtr->cur_status_flags &=
~(SHIP_AT_MAX_SPEED
| SHIP_BEYOND_MAX_SPEED
| SHIP_IN_GRAVITY_WELL);
StarShipPtr->cur_status_flags |= thrust_status;
StarShipPtr->RaceDescPtr->characteristics.thrust_increment = thrust_increment;
StarShipPtr->RaceDescPtr->characteristics.max_thrust = max_thrust;
// Reduce afterburner energy consumption to 2/3.
if (StarShipPtr->special_counter == 0)
{
DeltaEnergy (ElementPtr, -SPECIAL_ENERGY_COST);
StarShipPtr->special_counter = 3;
}
else if (StarShipPtr->special_counter == 2)
DeltaEnergy (ElementPtr, -SPECIAL_ENERGY_COST);
{
MISSILE_BLOCK MissileBlock;
MissileBlock.cx = ElementPtr->next.location.x;
MissileBlock.cy = ElementPtr->next.location.y;
MissileBlock.farray = StarShipPtr->RaceDescPtr->ship_data.special;
MissileBlock.face = 0;
MissileBlock.index = GetFrameCount (StarShipPtr->RaceDescPtr->ship_data.special[0]) - 1;
MissileBlock.sender = ElementPtr->playerNr;
MissileBlock.flags = IGNORE_SIMILAR;
MissileBlock.pixoffs = 0;
MissileBlock.speed = 0;
MissileBlock.hit_points = NAPALM_HITS;
MissileBlock.damage = NAPALM_DAMAGE;
MissileBlock.life = NAPALM_LIFE;
MissileBlock.preprocess_func = flame_napalm_preprocess;
MissileBlock.blast_offs = NAPALM_OFFSET;
hTrailElement = initialize_missile (&MissileBlock);
if (hTrailElement)
{
ELEMENT *TrailElementPtr;
LockElement (hTrailElement, &TrailElementPtr);
SetElementStarShip (TrailElementPtr, StarShipPtr);
TrailElementPtr->hTarget = 0;
TrailElementPtr->turn_wait = NAPALM_FADE_WAIT;
TrailElementPtr->state_flags |= NONSOLID;
SetPrimType (
&(GLOBAL (DisplayArray))[TrailElementPtr->PrimIndex],
NO_PRIM
);
/* normally done during preprocess, but because
* object is being inserted at head rather than
* appended after tail it may never get preprocessed.
*/
TrailElementPtr->next = TrailElementPtr->current;
TrailElementPtr->state_flags |= PRE_PROCESS;
UnlockElement (hTrailElement);
InsertElement (hTrailElement, GetHeadElement ());
ProcessSound (SetAbsSoundIndex (
/* BURNT_TOAST */
StarShipPtr->RaceDescPtr->ship_data.ship_sounds, 1), ElementPtr);
}
}
}
else if (StarShipPtr->RaceDescPtr->ship_info.energy_level < SPECIAL_ENERGY_COST)
DeltaEnergy (ElementPtr, -SPECIAL_ENERGY_COST); /* so text will flash */
}
static void
gas_collision (ELEMENT *ElementPtr0, POINT *pPt0, ELEMENT *ElementPtr1, POINT *pPt1)
{
STARSHIP *StarShipPtr;
STARSHIP *EnemyStarShipPtr;
BYTE enemyShipIsBaul = 0;
BYTE enemyShipIsChmmr = 0;
// This is the ship this gas cloud belongs to.
GetElementStarShip (ElementPtr0, &StarShipPtr);
// Check if the colliding element is a ship. If it is not, check if it's a projectile from Baul or Chmmr ship.
if (!elementsOfSamePlayer(ElementPtr0, ElementPtr1) && !(ElementPtr1->state_flags & PLAYER_SHIP)
&& ElementPtr1->playerNr > -1)
{
GetElementStarShip (ElementPtr1, &EnemyStarShipPtr);
if (EnemyStarShipPtr->SpeciesID == BAUL_ID)
enemyShipIsBaul = 1;
else if (EnemyStarShipPtr->SpeciesID == CHMMR_ID)
enemyShipIsChmmr = 1; // This is important because the gas can stick to zapsats.
}
// If colliding with Baul's spray weapon or shockwave, EXPLODE!!!
if (ElementPtr1->current.image.farray == StarShipPtr->RaceDescPtr->ship_data.weapon
|| (enemyShipIsBaul && ElementPtr1->current.image.farray == EnemyStarShipPtr->RaceDescPtr->ship_data.weapon))
{
// Move to shockwave graphics.
ElementPtr0->current.image.frame = SetAbsFrameIndex (ElementPtr0->current.image.frame, LAST_GAS_INDEX);
ElementPtr0->next.image.frame = SetAbsFrameIndex (ElementPtr0->current.image.frame, LAST_GAS_INDEX);
// Remove the lock on enemy ship and make the gas die on next turn.
ElementPtr0->hTarget = 0;
ElementPtr0->life_span = 1;
// Don't do the gas dissolve anim now that the shockwave appears.
ElementPtr0->death_func = NULL;
// Generate the actual shockwave.
generate_shockwave (ElementPtr0, -1); // XXX ElementPtr1->playerNr);
}
// If colliding with enemy ship, stick to the ship.
// Also stick to Chmmr's zapsats.
else if (ElementPtr0->state_flags & IGNORE_VELOCITY
&& ElementPtr1->playerNr != ElementPtr0->playerNr
&& (ElementPtr1->state_flags & PLAYER_SHIP
|| (enemyShipIsChmmr && ElementPtr1->mass_points == 10) ))
{
HELEMENT hGasElement;
HELEMENT hTargetElement;
ELEMENT *GasPtr;
// Create a new gas element which is sticking to the enemy ship.
if ((hGasElement = AllocElement ()))
{
LockElement (hGasElement, &GasPtr);
if (GasPtr->state_flags == 0) /* not allocated before */
{
InsertElement (hGasElement, GetHeadElement ());
GasPtr->current = ElementPtr0->next;
GasPtr->next = GasPtr->current;
GasPtr->playerNr = ElementPtr0->playerNr;
GasPtr->state_flags = FINITE_LIFE | GASSY_SUBSTANCE | CHANGING;
GasPtr->preprocess_func = gas_preprocess;
GasPtr->collision_func = gas_collision;
SetPrimType (&(GLOBAL (DisplayArray))[GasPtr->PrimIndex], NO_PRIM);
SetElementStarShip (GasPtr, StarShipPtr);
GetElementStarShip (ElementPtr1, &StarShipPtr);
// Ships and Chmmr Zapsats require different ways of making them the target of the gas cloud.
if (ElementPtr1->state_flags & PLAYER_SHIP)
GasPtr->hTarget = StarShipPtr->hShip;
else
{
GasPtr->life_span = 0;
LockElement (ElementPtr1, &hTargetElement);
GasPtr->hTarget = hTargetElement;
}
}
GasPtr->hit_points = ElementPtr0->hit_points;
GasPtr->life_span = ElementPtr0->life_span;
GasPtr->thrust_wait = 1;
GasPtr->weapon_element_index = ElementPtr0->weapon_element_index;
GasPtr->turn_wait = (BYTE)(1 << ((BYTE)TFB_Random () & 1)); /* LEFT or RIGHT */
GasPtr->death_func = gas_death;
UnlockElement (hGasElement);
}
// Erase the original gas element.
ElementPtr0->hit_points = 0;
ElementPtr0->life_span = 0;
ElementPtr0->state_flags |= DISAPPEARING | COLLISION | NONSOLID;
}
(void) pPt0; /* Satisfying compiler (unused parameter) */
(void) pPt1; /* Satisfying compiler (unused parameter) */
}
void PriorityQueue::Heapify(int array[], int n)
{
for(int i=0;i<n;i++)
InsertElement(array[i]);
}
void C4Network2ClientListBox::Update()
{
// sync with client list
ListItem *pItem = static_cast<ListItem *>(pClientWindow->GetFirst()), *pNext;
const C4Client *pClient = nullptr;
while ((pClient = Game.Clients.getClient(pClient)))
{
// skip host in startup board
if (IsStartup() && pClient->isHost()) continue;
// deleted client(s) present? this will also delete unneeded client connections of previous client
while (pItem && (pItem->GetClientID() < pClient->getID()))
{
pNext = static_cast<ListItem *>(pItem->GetNext());
delete pItem; pItem = pNext;
}
// same present for update?
// need not check for connection ID, because a client item will always be placed before the corresponding connection items
if (pItem && pItem->GetClientID() == pClient->getID())
{
pItem->Update();
pItem = static_cast<ListItem *>(pItem->GetNext());
}
else
// not present: insert (or add if pItem=nullptr)
InsertElement(new ClientListItem(this, pClient->getID()), pItem);
// update connections for client
// but no connections in startup board
if (IsStartup()) continue;
// enumerate client connections
C4Network2Client *pNetClient = pClient->getNetClient();
if (!pNetClient) continue; // local client does not have connections
C4Network2IOConnection *pLastConn = nullptr;
for (int i = 0; i<2; ++i)
{
C4Network2IOConnection *pConn = i ? pNetClient->getMsgConn() : pNetClient->getDataConn();
if (!pConn) continue;
if (pConn == pLastConn) continue; // combined connection: Display only one
pLastConn = pConn;
// del leading items
while (pItem && ((pItem->GetClientID() < pClient->getID()) || ((pItem->GetClientID() == pClient->getID()) && (pItem->GetConnectionID() < i))))
{
pNext = static_cast<ListItem *>(pItem->GetNext());
delete pItem; pItem = pNext;
}
// update connection item
if (pItem && pItem->GetClientID() == pClient->getID() && pItem->GetConnectionID() == i)
{
pItem->Update();
pItem = static_cast<ListItem *>(pItem->GetNext());
}
else
{
// new connection: create it
InsertElement(new ConnectionListItem(this, pClient->getID(), i), pItem);
}
}
}
// del trailing items
while (pItem)
{
pNext = static_cast<ListItem *>(pItem->GetNext());
delete pItem; pItem = pNext;
}
}
static void
pkunk_preprocess (ELEMENT *ElementPtr)
{
STARSHIP *StarShipPtr;
GetElementStarShip (ElementPtr, &StarShipPtr);
if (ElementPtr->state_flags & APPEARING)
{
HELEMENT hPhoenix = 0;
if ((BYTE)TFB_Random () & 1)
hPhoenix = AllocElement ();
if (hPhoenix)
{
ELEMENT *PhoenixPtr;
LockElement (hPhoenix, &PhoenixPtr);
PhoenixPtr->playerNr = ElementPtr->playerNr;
PhoenixPtr->state_flags = FINITE_LIFE | NONSOLID | IGNORE_SIMILAR;
PhoenixPtr->life_span = 1;
PhoenixPtr->death_func = intercept_pkunk_death;
SetElementStarShip (PhoenixPtr, StarShipPtr);
UnlockElement (hPhoenix);
InsertElement (hPhoenix, GetHeadElement ());
}
StarShipPtr->RaceDescPtr->data = (intptr_t) hPhoenix;
if (ElementPtr->hTarget == 0)
StarShipPtr->RaceDescPtr->preprocess_func = 0;
else
{
COUNT angle, facing;
ProcessSound (SetAbsSoundIndex (
StarShipPtr->RaceDescPtr->ship_data.ship_sounds, 1
), ElementPtr);
ElementPtr->life_span = PHOENIX_LIFE;
SetPrimType (&(GLOBAL (DisplayArray))[ElementPtr->PrimIndex],
NO_PRIM);
ElementPtr->state_flags |= NONSOLID | FINITE_LIFE | CHANGING;
facing = StarShipPtr->ShipFacing;
for (angle = OCTANT; angle < FULL_CIRCLE; angle += QUADRANT)
{
StarShipPtr->ShipFacing = NORMALIZE_FACING (
facing + ANGLE_TO_FACING (angle)
);
phoenix_transition (ElementPtr);
}
StarShipPtr->ShipFacing = facing;
}
}
if (StarShipPtr->RaceDescPtr->preprocess_func)
{
StarShipPtr->cur_status_flags &=
~(LEFT | RIGHT | THRUST | WEAPON | SPECIAL);
if (ElementPtr->life_span == NORMAL_LIFE)
{
ElementPtr->current.image.frame =
ElementPtr->next.image.frame =
SetEquFrameIndex (
ElementPtr->current.image.farray[0],
ElementPtr->current.image.frame);
SetPrimType (&(GLOBAL (DisplayArray))[ElementPtr->PrimIndex],
STAMP_PRIM);
InitIntersectStartPoint (ElementPtr);
InitIntersectEndPoint (ElementPtr);
InitIntersectFrame (ElementPtr);
ZeroVelocityComponents (&ElementPtr->velocity);
ElementPtr->state_flags &= ~(NONSOLID | FINITE_LIFE);
ElementPtr->state_flags |= CHANGING;
StarShipPtr->RaceDescPtr->preprocess_func = 0;
}
}
}
static void
thraddash_preprocess (ELEMENT *ElementPtr)
{
STARSHIP *StarShipPtr;
GetElementStarShip (ElementPtr, &StarShipPtr);
if (!(StarShipPtr->cur_status_flags & SPECIAL))
{
if ((StarShipPtr->old_status_flags & SPECIAL)
&& (StarShipPtr->cur_status_flags & SHIP_AT_MAX_SPEED))
StarShipPtr->cur_status_flags |= SHIP_BEYOND_MAX_SPEED;
}
else if (DeltaEnergy (ElementPtr, -SPECIAL_ENERGY_COST))
{
COUNT max_thrust, thrust_increment;
STATUS_FLAGS thrust_status;
HELEMENT hTrailElement;
if (!(StarShipPtr->old_status_flags & SPECIAL))
StarShipPtr->cur_status_flags &=
~(SHIP_AT_MAX_SPEED | SHIP_BEYOND_MAX_SPEED);
if (ElementPtr->thrust_wait == 0)
++ElementPtr->thrust_wait;
thrust_increment =
StarShipPtr->RaceDescPtr->characteristics.thrust_increment;
max_thrust = StarShipPtr->RaceDescPtr->characteristics.max_thrust;
StarShipPtr->RaceDescPtr->characteristics.thrust_increment =
SPECIAL_THRUST_INCREMENT;
StarShipPtr->RaceDescPtr->characteristics.max_thrust =
SPECIAL_MAX_THRUST;
thrust_status = inertial_thrust (ElementPtr);
StarShipPtr->cur_status_flags &=
~(SHIP_AT_MAX_SPEED
| SHIP_BEYOND_MAX_SPEED
| SHIP_IN_GRAVITY_WELL);
StarShipPtr->cur_status_flags |= thrust_status;
StarShipPtr->RaceDescPtr->characteristics.thrust_increment =
thrust_increment;
StarShipPtr->RaceDescPtr->characteristics.max_thrust = max_thrust;
{
MISSILE_BLOCK MissileBlock;
MissileBlock.cx = ElementPtr->next.location.x;
MissileBlock.cy = ElementPtr->next.location.y;
MissileBlock.farray = StarShipPtr->RaceDescPtr->ship_data.special;
MissileBlock.face = 0;
MissileBlock.index = GetFrameCount (
StarShipPtr->RaceDescPtr->ship_data.special[0]
) - 1;
MissileBlock.sender = ElementPtr->playerNr;
MissileBlock.flags = IGNORE_SIMILAR;
MissileBlock.pixoffs = 0;
MissileBlock.speed = 0;
MissileBlock.hit_points = NAPALM_HITS;
MissileBlock.damage = NAPALM_DAMAGE;
MissileBlock.life = NAPALM_LIFE;
MissileBlock.preprocess_func = flame_napalm_preprocess;
MissileBlock.blast_offs = NAPALM_OFFSET;
hTrailElement = initialize_missile (&MissileBlock);
if (hTrailElement)
{
ELEMENT *TrailElementPtr;
LockElement (hTrailElement, &TrailElementPtr);
SetElementStarShip (TrailElementPtr, StarShipPtr);
TrailElementPtr->hTarget = 0;
/* turn_wait is abused here to store the speed of the decay
* animation */
TrailElementPtr->turn_wait = NAPALM_DECAY_RATE;
TrailElementPtr->state_flags |= NONSOLID;
SetPrimType (
&(GLOBAL (DisplayArray))[TrailElementPtr->PrimIndex],
NO_PRIM
);
/* normally done during preprocess, but because
* object is being inserted at head rather than
* appended after tail it may never get preprocessed.
*/
TrailElementPtr->next = TrailElementPtr->current;
TrailElementPtr->state_flags |= PRE_PROCESS;
UnlockElement (hTrailElement);
InsertElement (hTrailElement, GetHeadElement ());
ProcessSound (SetAbsSoundIndex (
StarShipPtr->RaceDescPtr->ship_data.ship_sounds, 1), ElementPtr);
}
}
}
}
static void
confusion_collision (ELEMENT *ElementPtr0, POINT *pPt0,
ELEMENT *ElementPtr1, POINT *pPt1)
{
if (ElementPtr1->state_flags & PLAYER_SHIP)
{
HELEMENT hConfusionElement, hNextElement;
ELEMENT *ConfusionPtr;
STARSHIP *StarShipPtr;
GetElementStarShip (ElementPtr0, &StarShipPtr);
for (hConfusionElement = GetHeadElement ();
hConfusionElement; hConfusionElement = hNextElement)
{
LockElement (hConfusionElement, &ConfusionPtr);
if (elementsOfSamePlayer (ConfusionPtr, ElementPtr0)
&& ConfusionPtr->current.image.farray ==
StarShipPtr->RaceDescPtr->ship_data.special
&& (ConfusionPtr->state_flags & NONSOLID))
{
UnlockElement (hConfusionElement);
break;
}
hNextElement = GetSuccElement (ConfusionPtr);
UnlockElement (hConfusionElement);
}
if (hConfusionElement || (hConfusionElement = AllocElement ()))
{
LockElement (hConfusionElement, &ConfusionPtr);
if (ConfusionPtr->state_flags == 0) /* not allocated before */
{
InsertElement (hConfusionElement, GetHeadElement ());
ConfusionPtr->current = ElementPtr0->next;
ConfusionPtr->current.image.frame = SetAbsFrameIndex (
ConfusionPtr->current.image.frame, 8
);
ConfusionPtr->next = ConfusionPtr->current;
ConfusionPtr->playerNr = ElementPtr0->playerNr;
ConfusionPtr->state_flags = FINITE_LIFE | NONSOLID | CHANGING;
ConfusionPtr->preprocess_func = confuse_preprocess;
SetPrimType (
&(GLOBAL (DisplayArray))[ConfusionPtr->PrimIndex],
NO_PRIM
);
SetElementStarShip (ConfusionPtr, StarShipPtr);
GetElementStarShip (ElementPtr1, &StarShipPtr);
ConfusionPtr->hTarget = StarShipPtr->hShip;
}
ConfusionPtr->life_span = 400;
ConfusionPtr->turn_wait =
(BYTE)(1 << ((BYTE)TFB_Random () & 1)); /* LEFT or RIGHT */
UnlockElement (hConfusionElement);
}
ElementPtr0->hit_points = 0;
ElementPtr0->life_span = 0;
ElementPtr0->state_flags |= DISAPPEARING | COLLISION | NONSOLID;
}
(void) pPt0; /* Satisfying compiler (unused parameter) */
(void) pPt1; /* Satisfying compiler (unused parameter) */
}
void AmayaSVGPanel::OnInsertElement(wxCommandEvent& event)
{
InsertElement(last_menu, event.GetId());
}
void
spawn_ion_trail (ELEMENT *ElementPtr)
{
STARSHIP *StarShipPtr;
SHIP_INFO *ShipInfoPtr;
HELEMENT hIonElement;
assert (ElementPtr->state_flags & PLAYER_SHIP);
// JMS: Get the pointers to element's owner ship.
// They are needed to see if the ship's thrust is damaged
GetElementStarShip (ElementPtr, &StarShipPtr);
ShipInfoPtr = &StarShipPtr->RaceDescPtr->ship_info;
hIonElement = AllocElement ();
if (hIonElement)
{
#define ION_LIFE 1
COUNT angle;
RECT r;
ELEMENT *IonElementPtr;
STARSHIP *StarShipPtr;
GetElementStarShip (ElementPtr, &StarShipPtr);
angle = FACING_TO_ANGLE (StarShipPtr->ShipFacing) + HALF_CIRCLE;
GetFrameRect (StarShipPtr->RaceDescPtr->ship_data.ship[0], &r);
r.extent.height = DISPLAY_TO_WORLD (r.extent.height + r.corner.y);
InsertElement (hIonElement, GetHeadElement ());
LockElement (hIonElement, &IonElementPtr);
IonElementPtr->playerNr = NEUTRAL_PLAYER_NUM;
IonElementPtr->state_flags = APPEARING | FINITE_LIFE | NONSOLID;
IonElementPtr->thrust_wait = ION_LIFE;
IonElementPtr->life_span = IonElementPtr->thrust_wait;
// When the element "dies", in the death_func
// 'cycle_ion_trail', it is given new life a number of
// times, by setting life_span to thrust_wait.
SetPrimType (&DisplayArray[IonElementPtr->PrimIndex], POINT_PRIM);
// JMS: Damaged thruster emits differently colored particles
if (ShipInfoPtr->damage_flags & DAMAGE_THRUST)
{
SetPrimColor (&DisplayArray[IonElementPtr->PrimIndex],
START_ION_COLOR_DAMAGED);
}
else
{
SetPrimColor (&DisplayArray[IonElementPtr->PrimIndex],
START_ION_COLOR);
}
IonElementPtr->colorCycleIndex = 0;
IonElementPtr->current.image.frame =
DecFrameIndex (stars_in_space);
IonElementPtr->current.image.farray = &stars_in_space;
IonElementPtr->current.location = ElementPtr->current.location;
IonElementPtr->current.location.x +=
(COORD)COSINE (angle, r.extent.height);
IonElementPtr->current.location.y +=
(COORD)SINE (angle, r.extent.height);
IonElementPtr->death_func = cycle_ion_trail;
SetElementStarShip (IonElementPtr, StarShipPtr);
{
/* normally done during preprocess, but because
* object is being inserted at head rather than
* appended after tail it may never get preprocessed.
*/
IonElementPtr->next = IonElementPtr->current;
--IonElementPtr->life_span;
IonElementPtr->state_flags |= PRE_PROCESS;
}
UnlockElement (hIonElement);
}
}
void AddElementToListStart(Node _head, Node _element)
{
InsertElement(_head, _element);
}
void Prim(int **a, dimension_t dimension, settings_t settings)
{
int w, h, x, y, i, j;
int **primMatrix, count = 0;
int randDir[] = {1, 2, 3, 4};
int done = 0, randNum = 0;
int print = 0;
coordList_t *rear, *element;
rear = NULL; element = NULL;
primMatrix = GenerateMinMatrix(dimension);
w = dimension.x / 2;
h = dimension.y / 2;
x = w / 2; y = h / 2;
primMatrix[y][x] |= IN_MAZE;
InsertElement(&rear, x, y);
while ( rear != NULL )
{
//delete
count = rand() % 42; // if you ask why, you sir, aren't a geek!
i = 0;
while ( i < count )
{
rear = rear->next;
i++;
}
element = rear->next;
rear->next = element->next;
x = element->j;
y = element->i;
if ( rear == element ) rear = NULL;
free(element);
//delete
primMatrix[y][x] |= IN_MAZE;
// ako ima komsije koji su deo lavirinta odaberi jedan od komsija i probij put
ShuffleArray(randDir);
for ( i = 0, done = 0; i < 4; i++ )
{
switch ( randDir[i] )
{
case 1:
if ( y - 1 >= 0 && (primMatrix[y-1][x] & IN_MAZE) )
{// up
primMatrix[y-1][x] &= ~DOWN_WALL;
primMatrix[y][x] &= ~UP_WALL;
done = 1;
}
break;
case 2:
if ( y + 1 < h && (primMatrix[y+1][x] & IN_MAZE) )
{//down
primMatrix[y+1][x] &= ~UP_WALL;
primMatrix[y][x] &= ~DOWN_WALL;
done = 1;
//printf("\n Probijen zid na dole %d %d", x, y+1);
}
break;
case 3:
if ( x - 1 >= 0 && (primMatrix[y][x-1] & IN_MAZE) )
{//left
primMatrix[y][x-1] &= ~RIGHT_WALL;
primMatrix[y][x] &= ~LEFT_WALL;
done = 1;
//printf("\n Probijen zid na levo %d %d", x-1, y);
}
break;
case 4:
if ( x + 1 < w && (primMatrix[y][x+1] & IN_MAZE) )
{//right
primMatrix[y][x+1] &= ~LEFT_WALL;
primMatrix[y][x] &= ~RIGHT_WALL;
done = 1;
//printf("\n Probijen zid na desno %d %d", x+1, y);
}
break;
default: printf("ZABOLO"), exit(64);
}
if ( done == 1 ) break;
}
if ( ++print % 5 == 0 ) { ConvertFromMin(primMatrix, a, dimension); LivePrint(a, dimension, settings); }
// dodaj sve komsije koje nisu deo lafirinta u redic
if ( y - 1 >= 0 && !(primMatrix[y-1][x] & IN_MAZE) )
{// up
if ( !FindInList(rear, x, y-1) )
InsertElement(&rear, x, y-1);
}
if ( y + 1 < h && !(primMatrix[y+1][x] & IN_MAZE) )
{//down
if ( !FindInList(rear, x, y+1) )
InsertElement(&rear, x, y+1);
}
if ( x - 1 >= 0 && !(primMatrix[y][x-1] & IN_MAZE) )
{//left
if ( !FindInList(rear, x-1, y) )
InsertElement(&rear, x-1, y);
}
if ( x + 1 < w && !(primMatrix[y][x+1] & IN_MAZE) )
{//right
if ( !FindInList(rear, x+1, y) )
InsertElement(&rear, x+1, y);
}
}
// promeni primovu u nasu sugavu reprezentaciju
for ( i = 0; i < dimension.y; i++ )
for ( j = 0; j < dimension.x; j++ )
if ( i == 0 || i == dimension.y-1 || j == 0 || j == dimension.x-1 ) a[i][j] = 1;
else a[i][j] = 0;
for ( i = 0; i < h; i++ )
for ( j = 0; j < w; j++ )
{
if ( primMatrix[i][j] & UP_WALL )
{
a[i*2][j*2] = 1;
a[i*2][j*2 + 1] = 1;
a[i*2][j*2 + 2] = 1;
}
if ( primMatrix[i][j] & LEFT_WALL )
{
a[i*2][j*2] = 1;
a[i*2 + 1][j*2] = 1;
a[i*2 + 2][j*2] = 1;
}
}
}
