Bullet* Bullet_Create(int collisionType) {
Bullet* bullet = malloc(sizeof(Bullet));
bullet->entity = Entity_Create(bullet);
bullet->entity->update = Bullet_Update;
bullet->entity->destroy = Bullet_Destroy;
bullet->entity->draw = Bullet_Draw;
bullet->entity->collision = Bullet_Collision;
bullet->entity->collisionType = collisionType;
if(collisionType == COLLISION_TYPE_BULLET_PLAYER)
{
bullet->entity->width = 6;
bullet->entity->height = 4;
}
else
{
bullet->entity->width = 10;
bullet->entity->height = 7;
}
bullet->damage = 10;
bullet->maxLifeTime = 250;
bullet->lifeTime = 0;
return bullet;
}
Healthpack* Healthpack_Create(int collisionType) {
Healthpack* this = malloc(sizeof(Healthpack));
this->entity = Entity_Create(this);
this->entity->width = 32;
this->entity->height = 32;
this->entity->draw = Healthpack_Draw;
this->entity->collisionType = collisionType;
this->healthBonus = 50;
return this;
}
TriggerArea* TriggerArea_Create(void (*onPlayerEnter)(TriggerArea*, Player*), void (*onPlayerLeave)(TriggerArea*, Player*)) {
TriggerArea* this = malloc(sizeof(TriggerArea));
this->entity = Entity_Create(this);
this->entity->update = TriggerArea_Update;
this->entity->collision = TriggerArea_Collision;
this->entity->posY = 0;
this->entity->width = 100;
this->entity->height = SCREEN_HEIGHT;
this->onPlayerEnter = onPlayerEnter;
this->onPlayerLeave = onPlayerLeave;
return this;
}
Storyboard* Storyboard_Create(char* text)
{
Storyboard* storyboard = (Storyboard*)malloc(sizeof(Storyboard));
storyboard->entity = Entity_Create(storyboard);
storyboard->entity->posY = 0;
storyboard->entity->posX = 0;
storyboard->entity->width = 320;
storyboard->entity->height = 100;
storyboard->entity->update = Storyboard_Update;
storyboard->entity->draw = Storyboard_Draw;
storyboard->entity->destroy = Storyboard_Destroy;
storyboard->text = text;
storyboard->next = NULL;
storyboard->buttonDown = false;
storyboard->onClose = NULL;
return storyboard;
}
void Inputs_ApplyInputsLevelEditor(Controls* controls,
World* world, Window* level_editor,
GameManager* gm)
{
rotate_timer += delta_g;
if(pressedKeys[SDLK_F1] && SDL_GetTicks() - switch_timer > 200)
{
draw_grid_g = draw_grid_g? false : true;
}
if(pressedKeys[SDLK_F7] && SDL_GetTicks() - switch_timer > 2000)
{
switch_timer = SDL_GetTicks();
LevelEditor_QuickTry(world);
}
int position_in_array = controls->mouseTileY * world->map_width + controls->mouseTileX;
if(controls->temp_object_to_create != NULL)
{
if(pressedKeys[SDLK_f] && !previousPressedKeys_g[SDLK_f])
{
SDL_WarpMouseInWindow(Graphics_GetWindow(),
(controls->mouseTileX * TILE_SIZE - world->player.playerC->cameraX),
controls->mouseTileY * TILE_SIZE - world->player.playerC->cameraY);
}
if(pressedKeys[SDLK_RIGHT] && !previousPressedKeys_g[SDLK_RIGHT])
{
SDL_WarpMouseInWindow(Graphics_GetWindow(),
(controls->mouseX + 1 ),
controls->mouseY);
}
if(pressedKeys[SDLK_LEFT] && !previousPressedKeys_g[SDLK_LEFT])
{
SDL_WarpMouseInWindow(Graphics_GetWindow(),
(controls->mouseX - 1 ),
controls->mouseY);
}
if(pressedKeys[SDLK_UP] && !previousPressedKeys_g[SDLK_UP])
{
SDL_WarpMouseInWindow(Graphics_GetWindow(),
(controls->mouseX ),
controls->mouseY - 1);
}
if(pressedKeys[SDLK_DOWN] && !previousPressedKeys_g[SDLK_DOWN])
{
SDL_WarpMouseInWindow(Graphics_GetWindow(),
(controls->mouseX),
controls->mouseY + 1);
}
if(controls->mouseWheelPos < 0 && rotate_timer > 50)
{
if(controls->temp_object_to_create->angle == 0)
{
controls->temp_object_to_create->angle = HALF_PI;
}
else if(controls->temp_object_to_create->angle <= HALF_PI + 0.1f)
{
controls->temp_object_to_create->angle = HALF_PI * 2;
}
else if(controls->temp_object_to_create->angle <= HALF_PI * 2 + 0.1f)
{
controls->temp_object_to_create->angle = HALF_PI * 3;
}
else if(controls->temp_object_to_create->angle <= HALF_PI * 3 + 0.1f)
{
controls->temp_object_to_create->angle = 0;
}
rotate_timer = 0;
}
if(controls->mouseWheelPos > 0 && rotate_timer > 50)
{
if(controls->temp_object_to_create->angle == 0)
{
controls->temp_object_to_create->angle = HALF_PI * 3;
}
else if(controls->temp_object_to_create->angle >= HALF_PI * 3 - 0.1f)
{
controls->temp_object_to_create->angle = HALF_PI * 2;
}
else if(controls->temp_object_to_create->angle >= HALF_PI * 2 - 0.1f)
{
controls->temp_object_to_create->angle = HALF_PI;
}
else if(controls->temp_object_to_create->angle >= HALF_PI - 0.2f)
{
controls->temp_object_to_create->angle = 0;
}
rotate_timer = 0;
}
controls->temp_object_to_create->x = controls->mousePositionInWorldX;
controls->temp_object_to_create->y = controls->mousePositionInWorldY;
BoundingBox_Update(controls->temp_object_to_create);
}
Vector* monsters_vector = &world->monsters_vector;
if(BoundingBox_CheckPointCollision(controls->mouseX, controls->mouseY, &level_editor->box))
{
controls->hovering_on_window = true;
//selecting button in level_editor
if(controls->pressedMouseButtons[SDL_BUTTON_LEFT])
{
for(int i = 0 ; i < level_editor->nb_of_buttons ; i++)
{
if(BoundingBox_CheckPointCollision(controls->mouseX,
controls->mouseY,
&level_editor->buttons[i].box))
{
level_editor->active_button = &level_editor->buttons[i];
if(controls->temp_object_to_create != NULL)
{
Entity_Destroy(controls->temp_object_to_create);
free(controls->temp_object_to_create);
}
controls->temp_object_to_create = Entity_Create(level_editor->active_button->main_category,
level_editor->active_button->button_type,
controls->mouseX, controls->mouseY,
0, world);
}
}
}
//showing window resizing cursor
if((controls->mouseX > level_editor->box.right - 10 ||
controls->mouseX < level_editor->box.left + 10) &&
controls->active_window == NULL)
{
controls->cursor_resize_left_right = true;
if(controls->pressedMouseButtons[SDL_BUTTON_LEFT] &&
controls->previousPressedMouseButtons[SDL_BUTTON_LEFT] &&
controls->mouseX > level_editor->box.right - 10)
{
controls->resizing_right = true;
}
if(controls->pressedMouseButtons[SDL_BUTTON_LEFT] &&
controls->previousPressedMouseButtons[SDL_BUTTON_LEFT] &&
controls->mouseX < level_editor->box.left + 10)
{
controls->resizing_left = true;
}
}
else
{
controls->cursor_resize_left_right = false;
}
//clicking on the level editor window
if(controls->pressedMouseButtons[SDL_BUTTON_LEFT] &&
controls->previousPressedMouseButtons[SDL_BUTTON_LEFT] &&
!controls->cursor_resize_left_right)
{
controls->active_window = level_editor;
}
}
else //if not hovering on the window
{
controls->cursor_resize_left_right = false;
controls->cursor_resize_up_down = false;
controls->hovering_on_window = false;
}
//if you've clicked on the window and then stopped clicking, it's not "active" anymore
if(controls->active_window != NULL &&
!controls->previousPressedMouseButtons[SDL_BUTTON_LEFT])
{
controls->active_window = NULL;
}
//resizing window
if(controls->resizing_right || controls->resizing_left)
{
controls->cursor_resize_left_right = true;
if(!controls->pressedMouseButtons[SDL_BUTTON_LEFT] &&
!controls->previousPressedMouseButtons[SDL_BUTTON_LEFT])
{
controls->resizing_right = false;
controls->resizing_left = false;
}
if(controls->resizing_right)
{
Window_ResizeRight(level_editor, controls->mouseX - controls->previousMouseX);
}
else if(controls->resizing_left)
{
Window_ResizeLeft(level_editor, controls->mouseX - controls->previousMouseX);
}
}
//moving window
if(controls->active_window != NULL &&
controls->pressedMouseButtons[SDL_BUTTON_LEFT] &&
controls->previousPressedMouseButtons[SDL_BUTTON_LEFT] &&
!controls->resizing_left && !controls->resizing_right)
{
Window_Move(level_editor,
controls->mouseX - controls->previousMouseX,
controls->mouseY - controls->previousMouseY);
}
if(pressedKeys[SDLK_LCTRL])
{
unlimited_creation = true;
}
else
{
unlimited_creation = false;
}
//if not hovering and not moving window
//we can create/delete stuff on the map
if(!controls->active_window && !controls->hovering_on_window)
{
if (level_editor->active_button != NULL)
{
Main_Category category = level_editor->active_button->main_category;
int obj_type = level_editor->active_button->button_type;
if(!rectangle_selection_create &&
(controls->pressedMouseButtons[SDL_BUTTON_RIGHT] ||
pressedKeys[SDLK_SPACE]))
{
if (controls->mouseTileX < world->map_width && controls->mouseTileX > 0 &&
controls->mouseTileY < world->map_height && controls->mouseTileY > 0)
{
//pressing shift activate the rectangle selection tool
if((category == Cat_Wall || category == Cat_Ground) &&
pressedKeys[SDLK_LSHIFT])
{
rectangle_selection_startX = controls->mousePositionInWorldX;
rectangle_selection_startY = controls->mousePositionInWorldY;
rectangle_selection_create = true;
}
LevelEditor_CreateObject(category, obj_type, controls->tileInPixelsX, controls->tileInPixelsY,
position_in_array, controls->mousePositionInWorldX,
controls->mousePositionInWorldY, world, unlimited_creation,
controls->temp_object_to_create->angle);
}
else
printf("out of bound!!!");
}
//remove wall (replace it with empty entity)
if(pressedKeys[SDLK_c])
{
}
//deleting monster
if(pressedKeys[SDLK_x])
{
if(pressedKeys[SDLK_LSHIFT] && !rectangle_selection_delete)
{
rectangle_selection_startX = controls->mousePositionInWorldX;
rectangle_selection_startY = controls->mousePositionInWorldY;
rectangle_selection_delete = true;
}
if(!rectangle_selection_delete)
{
LevelEditor_UpdateWallsCorners(position_in_array, world);
free(world->map[position_in_array]);
world->map[position_in_array] = NULL;
}
for(int i = 0 ; i < Vector_Count(&world->monsters_vector) ; i++)
{
Entity* mob = (Entity*)Vector_Get(&world->monsters_vector, i);
if(BoundingBox_CheckPointCollision(controls->mousePositionInWorldX,
controls->mousePositionInWorldY,
&mob->box))
{
Entity_Destroy(mob);
Vector_Delete(&world->monsters_vector, i);
}
}
for(int i = 0 ; i < Vector_Count(&world->bonus_vector) ; i++)
{
Entity* bonus = (Entity*)Vector_Get(&world->bonus_vector, i);
if(BoundingBox_CheckPointCollision(controls->mousePositionInWorldX,
controls->mousePositionInWorldY,
&bonus->box))
{
Entity_Destroy(bonus);
Vector_Delete(&world->bonus_vector, i);
}
}
for(int i = 0 ; i < Vector_Count(&world->props_vector) ; i++)
{
Entity* obj = (Entity*)Vector_Get(&world->props_vector, i);
if(BoundingBox_CheckPointCollision(controls->mousePositionInWorldX,
controls->mousePositionInWorldY,
&obj->box))
{
Entity_Destroy(obj);
Vector_Delete(&world->props_vector, i);
}
}
for(int i = 0 ; i < Vector_Count(&world->decals_vector) ; i++)
{
Entity* obj = (Entity*)Vector_Get(&world->decals_vector, i);
if(BoundingBox_CheckPointCollision(controls->mousePositionInWorldX,
controls->mousePositionInWorldY,
&obj->box))
{
Entity_Destroy(obj);
Vector_Delete(&world->decals_vector, i);
}
}
}
/*stopping pressing left shift stop the selection and creates the selection tile
in the selection (only if it's a tile and not a monster/object
*/
if((rectangle_selection_create || rectangle_selection_delete) && pressedKeys[SDLK_LSHIFT])
{
rectangle_selection_endX = controls->mousePositionInWorldX;
rectangle_selection_endY =controls->mousePositionInWorldY;
int startX = rectangle_selection_startX;
int endX = rectangle_selection_endX;
int startY = rectangle_selection_startY;
int endY = rectangle_selection_endY;
if(rectangle_selection_endY <= rectangle_selection_startY)
{
startY = rectangle_selection_endY;
endY = rectangle_selection_startY;
}
if(rectangle_selection_endX <= rectangle_selection_startX)
{
startX = rectangle_selection_endX;
endX = rectangle_selection_startX;
}
int tileStartX = startX / TILE_SIZE;
int tileStartY = startY / TILE_SIZE;
int tileEndX = endX / TILE_SIZE;
int tileEndY = endY / TILE_SIZE;
for(int y = tileStartY ; y <= tileEndY ; y++)
{
for(int x = tileStartX ; x <= tileEndX ; x++)
{
position_in_array = y * world->map_width + x;
if(rectangle_selection_create)
{
int obj_type = level_editor->active_button->button_type;
LevelEditor_CreateObject(category, obj_type, x * TILE_SIZE, y * TILE_SIZE,
position_in_array, controls->mousePositionInWorldX,
controls->mousePositionInWorldY, world, unlimited_creation,
controls->temp_object_to_create->angle);
}
else if(rectangle_selection_delete)
{
LevelEditor_UpdateWallsCorners(position_in_array, world);
free(world->map[position_in_array]);
world->map[position_in_array] = NULL;
}
}
}
if(rectangle_selection_delete)
{
for(int i = 0 ; i < Vector_Count(&world->monsters_vector) ; i++)
{
Entity* obj = (Entity*)Vector_Get(&world->monsters_vector, i);
if(obj->box.right > startX &&
obj->box.left < endX &&
obj->box.bottom > startY &&
obj->box.top < endY)
{
Entity_Destroy(obj);
Vector_Delete(&world->monsters_vector, i);
}
}
for(int i = 0 ; i < Vector_Count(&world->bonus_vector) ; i++)
{
Entity* obj = (Entity*)Vector_Get(&world->bonus_vector, i);
if(obj->box.right > startX &&
obj->box.left < endX &&
obj->box.bottom > startY &&
obj->box.top < endY)
{
Entity_Destroy(obj);
Vector_Delete(&world->bonus_vector, i);
}
}
for(int i = 0 ; i < Vector_Count(&world->props_vector) ; i++)
{
Entity* obj = (Entity*)Vector_Get(&world->props_vector, i);
if(obj->box.right > startX &&
obj->box.left < endX &&
obj->box.bottom > startY &&
obj->box.top < endY)
{
Entity_Destroy(obj);
Vector_Delete(&world->props_vector, i);
}
}
for(int i = 0 ; i < Vector_Count(&world->decals_vector) ; i++)
{
Entity* obj = (Entity*)Vector_Get(&world->decals_vector, i);
if(obj->box.right > startX &&
obj->box.left < endX &&
obj->box.bottom > startY &&
obj->box.top < endY)
{
Entity_Destroy(obj);
Vector_Delete(&world->decals_vector, i);
}
}
}
}
if((rectangle_selection_create || rectangle_selection_delete) && !pressedKeys[SDLK_LSHIFT])
{
rectangle_selection_create = false;
rectangle_selection_delete = false;
}
}
//deleting every monster
if(pressedKeys[SDLK_u])
{
// Vector_Clear(&world->monsters_vector); leads to memory leak
}
//cancel current selected object
/*if(pressedKeys[SDLK_e])
{
level_editor->active_button = NULL;
}*/
//switch mobs AI
if(pressedKeys[SDLK_a] &&
SDL_GetTicks() - controls->last_ai_switch > 150)
{
if(gm->ai_on)
{
gm->ai_on = false;
}
else
{
gm->ai_on = true;
}
controls->last_ai_switch = SDL_GetTicks();
}
}
}
void Player_Create( ) {
if( player ) {
Player_Free( );
Memory_Free( player );
}
player = Memory_New( TPlayer );
// create main pivot
player->pivot = Entity_Create( );
// create camera
player->cameraPivot = Entity_Create();
Entity_MakeCamera( player->cameraPivot );
Entity_Attach( player->cameraPivot, player->pivot );
player->cameraPivot->localPosition = Vec3_Set( 0, 0.4, 0 );
// add physical body
Shape_CreateSphere( &player->shape, 1.0f );
Body_Create( &player->body, &player->shape );
Dynamics_AddBody( &player->body );
player->body.position.y = 10;
player->body.elasticity = 0.05f;
player->cameraOffset = Vec3_Set( 0, 0.4, 0 );
player->cameraShakeOffset = Vec3_Zero();
player->velocity = Vec3_Zero();
player->destVelocity = Vec3_Zero();
// set parameters
player->speed = 4.5f;
player->speedMultiplier = 1.8f;
player->jumpStrength = 0.1f;
player->mouseSensivity = 0.2f;
player->yaw = 0.0f;
player->pitch = 0.0f;
player->maxPitch = M_PI / 2.0;
player->pathLength = 0.0f;
player->crouchRadius = 0.5f;
player->standRadius = 1.0f;
player->crouch = false;
player->move = false;
player->run = false;
player->onGround = false;
player->cameraShakeCoeff = 0.0f;
// ==================
// step sounds
Player_SetSoundGroup( "data/sounds/dirt", STEP_SOIL, "data/materials/soil.mtl" );
Player_SetSoundGroup( "data/sounds/stonestep", STEP_ROCK, "data/materials/stone.mtl" );
Player_SetSoundGroup( "data/sounds/wood", STEP_WOOD, "data/materials/wood.mtl" );
Player_SetSoundGroup( "data/sounds/metal", STEP_METAL, "data/materials/metal.mtl" );
// set default step sounds
player->stepSoundGroup = &player->stepSounds[STEP_SOIL];
player->weapon = Weapon_Create( WEAPON_BLASTER );
Entity_Attach( player->weapon->model, player->cameraPivot );
player->interface.font = Font_LoadFromFile( "data/fonts/font3.ttf", 16 );
player->interface.ammo = GUI_CreateText( Renderer_GetScreenResolutionWidth() - 200, Renderer_GetScreenResolutionHeight() - 200, 190, 190, "Ammo:\n", player->interface.font );
}
//
// =======================================================================================================================
// CreateEntity Creates a new entity based on the currently selected brush and entity type.
// =======================================================================================================================
//
void CEntityDlg::CreateEntity() {
entity_t *petNew;
bool forceFixed = false;
// check to make sure we have a brush
CXYWnd *pWnd = g_pParentWnd->ActiveXY();
if (pWnd) {
CRect rctZ;
pWnd->GetClientRect(rctZ);
brush_t *pBrush;
if (selected_brushes.next == &selected_brushes) {
pBrush = CreateEntityBrush(g_nSmartX, rctZ.Height() - 1 - g_nSmartY, pWnd);
forceFixed = true;
}
}
else {
if (selected_brushes.next == &selected_brushes) {
MessageBox("You must have a selected brush to create an entity", "info", 0);
return;
}
}
int index = comboClass.GetCurSel();
if (index == LB_ERR) {
MessageBox("You must have a selected class to create an entity", "info", 0);
return;
}
CString str;
comboClass.GetLBText(index, str);
if (!stricmp(str, "worldspawn")) {
MessageBox("Can't create an entity with worldspawn.", "info", 0);
return;
}
eclass_t *pecNew = Eclass_ForName (str, false);
// create it
if ((GetAsyncKeyState(VK_CONTROL) & 0x8000)) {
// MAJOR hack for xian
extern void Brush_CopyList(brush_t *pFrom, brush_t *pTo);
brush_t temp_brushes;
temp_brushes.next = &temp_brushes;
Brush_CopyList(&selected_brushes, &temp_brushes);
Select_Deselect();
brush_t *pBrush = temp_brushes.next;
while (pBrush != NULL && pBrush != &temp_brushes) {
brush_t *pNext = pBrush->next;
Brush_RemoveFromList(pBrush);
Brush_AddToList(pBrush, &selected_brushes);
pBrush = pNext;
petNew = Entity_Create(pecNew, forceFixed);
Select_Deselect();
}
} else if ((GetAsyncKeyState(VK_SHIFT) & 0x8000)) {
Select_Ungroup();
petNew = Entity_Create(pecNew, forceFixed);
} else {
petNew = Entity_Create(pecNew, forceFixed);
}
if (petNew == NULL) {
MessageBox("Failed to create entity.", "info", 0);
return;
}
if (selected_brushes.next == &selected_brushes) {
editEntity = world_entity;
}
else {
editEntity = selected_brushes.next->owner;
}
SetKeyValPairs();
Select_Deselect();
Select_Brush(editEntity->brushes.onext);
Sys_UpdateWindows(W_ALL);
}
void CreateEntity(void)
{
eclass_t *pecNew;
entity_t *petNew;
int i;
HWND hwnd;
char sz[1024];
// check to make sure we have a brush
if (selected_brushes.next == &selected_brushes)
{
MessageBox(g_qeglobals.d_hwndMain, "You must have a selected brush to create an entity"
, "info", 0);
return;
}
// find out what type of entity we are trying to create
hwnd = hwndEnt[EntList];
i = SendMessage(hwndEnt[EntList], LB_GETCURSEL, 0, 0);
if (i < 0)
{
MessageBox(g_qeglobals.d_hwndMain, "You must have a selected class to create an entity"
, "info", 0);
return;
}
SendMessage(hwnd, LB_GETTEXT, i, (LPARAM)sz);
if (!stricmp(sz, "worldspawn"))
{
MessageBox(g_qeglobals.d_hwndMain, "Can't create an entity with worldspawn.", "info", 0);
return;
}
pecNew = Eclass_ForName(sz, false);
// create it
petNew = Entity_Create(pecNew);
if (petNew == NULL)
{
MessageBox(g_qeglobals.d_hwndMain, "Failed to create entity.", "info", 0);
return;
}
if (selected_brushes.next == &selected_brushes)
edit_entity = world_entity;
else
edit_entity = selected_brushes.next->owner;
SetKeyValuePairs();
Select_Deselect ();
Select_Brush (edit_entity->brushes.onext);
Sys_UpdateWindows(W_ALL);
}
void LevelEditor_ReadEntity(FILE* save_file, Entity* buffer, World* world)
{
Main_Category main_cat;
int sub_category;
float angle, x, y;
fread(&main_cat, sizeof(Main_Category), 1, save_file);
fread(&sub_category, sizeof(int), 1, save_file);
fread(&x, sizeof(float), 1, save_file);
fread(&y, sizeof(float), 1, save_file);
fread(&angle, sizeof(float), 1, save_file);
free(buffer);
buffer = Entity_Create(main_cat, sub_category, x, y, angle, world);
fread(&buffer->box, sizeof(Box), 1, save_file);
fread(&buffer->alive, sizeof(bool), 1, save_file);
fread(&buffer->alive_timer, sizeof(bool), 1, save_file);
fread(&buffer->is_ennemy, sizeof(bool), 1, save_file);
fread(&buffer->solid, sizeof(bool), 1, save_file);
fread(&buffer->collision_direction, sizeof(Direction), 1, save_file);
bool has_movementC = false;
fread(&has_movementC, sizeof(bool), 1, save_file);
if(has_movementC != false)
{
MovementC* mc = buffer->movementC;
fread(&mc->speed, sizeof(float), 1, save_file);
fread(&mc->dx, sizeof(float), 1, save_file);
fread(&mc->dy, sizeof(float), 1, save_file);
}
bool is_zombie = false;
fread(&is_zombie, sizeof(bool), 1, save_file);
if(is_zombie != false)
{
ZombieC* zc = buffer->zombieC;
fread(&zc->aggressive, sizeof(bool), 1, save_file);
fread(&zc->idling, sizeof(bool), 1, save_file);
fread(&zc->rand_move_timer, sizeof(int), 1, save_file);
fread(&zc->zombie_type, sizeof(Zombie_Type), 1, save_file);
fread(&zc->dodging_timer, sizeof(int), 1, save_file);
fread(&zc->ai_timer, sizeof(int), 1, save_file);
fread(&zc->attack_timer, sizeof(int), 1, save_file);
fread(&zc->shoot_timer, sizeof(int), 1, save_file);
fread(&zc->pattern_timer, sizeof(int), 1, save_file);
fread(&zc->shoots_fired_in_pattern, sizeof(int), 1, save_file);
fread(&zc->pattern_direction_right, sizeof(bool), 1, save_file);
fread(&zc->spot_timer, sizeof(bool), 1, save_file);
}
bool has_weaponC = true;
fread(&has_weaponC, sizeof(bool), 1, save_file);
if(has_weaponC)
{
WeaponsC* wc = buffer->weaponsC;
for(int i = 0 ; i < NB_WEAPON_TYPES ; i++)
{
fread(&wc->bullets[i], sizeof(int), 1, save_file);
}
fread(&wc->is_monster, sizeof(bool), 1, save_file);
fread(&wc->last_reload, sizeof(int), 1, save_file);
fread(&wc->reloading, sizeof(bool), 1, save_file);
fread(&wc->reload_timer, sizeof(int), 1, save_file);
//we read only the weapon type, then
//we'll find the weapon in the inventory and set the pointer to it
Weapon_Type current_weapon = No_Weapon;
fread(¤t_weapon, sizeof(Weapon_Type), 1, save_file);
int nb_of_weapons = 0;
fread(&nb_of_weapons, sizeof(int), 1, save_file);
for(int i = 0 ; i < nb_of_weapons ; i++)
{
Weapon_Type weapon_type = No_Weapon;
fread(&weapon_type, sizeof(Weapon_Type), 1, save_file);
Weapon* weapon = Weapon_Create(weapon_type);
fread(&weapon->last_shot, sizeof(int), 1, save_file);
fread(&weapon->magazine_bullets, sizeof(int), 1, save_file);
if(weapon_type == current_weapon)
{
wc->current_weapon = weapon;
}
weapon->parent = wc;
WeaponsComponent_AddWeaponToInventory(wc, weapon);
}
}
}
void LevelEditor_CreateObject(Main_Category category, int obj_type, int x, int y,
int position_in_array, float mousePositionInWorldX,
float mousePositionInWorldY, World* world, bool unlimited,
float angle)
{
if(category == Cat_Wall || category == Cat_Door)
{
free(world->map[position_in_array]);
world->map[position_in_array] = Entity_Create(category, obj_type, x, y, angle, world);
}
else if(category == Cat_Ground)
{
Entity_Destroy(world->ground_map[position_in_array]);
free(world->ground_map[position_in_array]);
world->ground_map[position_in_array] = Entity_Create(category, obj_type, x, y, angle, world);
}
else if(category == Cat_Zombie &&
(SDL_GetTicks() - building_time > 150 || unlimited))
{
Vector_Push(&world->monsters_vector,
Entity_Create(category, obj_type,
mousePositionInWorldX,
mousePositionInWorldY,
0, world));
building_time = SDL_GetTicks();
}
else if(category == Cat_Prop &&
(SDL_GetTicks() - building_time > 150 || unlimited))
{
Vector_Push(&world->props_vector,
Entity_Create(category, obj_type,
mousePositionInWorldX,
mousePositionInWorldY,
angle, world));
building_time = SDL_GetTicks();
}
else if(category == Cat_Decal &&
(SDL_GetTicks() - building_time > 150 || unlimited))
{
Vector_Push(&world->decals_vector,
Entity_Create(category, obj_type,
mousePositionInWorldX,
mousePositionInWorldY,
angle, world));
building_time = SDL_GetTicks();
}
else if(category == Cat_Event &&
(SDL_GetTicks() - building_time > 150))
{
//there can be only 1 player start and end of level
for(int i = 0 ; i < Vector_Count(&world->events_vector) ; i++)
{
Entity* map_event = (Entity*)Vector_Get(&world->events_vector, i);
if((obj_type == Event_Player_Start || obj_type == Event_End_Level )&&
obj_type == map_event->sub_category)
{
Vector_Delete(&world->events_vector, i);
}
}
Vector_Push(&world->events_vector, Entity_Create(category, obj_type, x, y, 0, world));
building_time = SDL_GetTicks();
}
else if(category == Cat_Bonus && (SDL_GetTicks() - building_time > 150 ||
unlimited))
{
Vector_Push(&world->bonus_vector, Entity_Create(category, obj_type, mousePositionInWorldX, mousePositionInWorldY, 0, world));
building_time = SDL_GetTicks();
}
}
