Beispiel #1
0
/**
 * \brief Change door state
 * \param[in] Door Door state to change
 */
PRIVATE void Door_ChangeDoorState( doors_t *Door )
{
	if( Door->action < dr_opening )
	{
		Door_Open( Door );
	}
	else if( Door->action == dr_open && CanCloseDoor( Door->tilex, Door->tiley, Door->vertical ) )
	{
		Door->action = dr_closing;
		Door->ticcount = DOOR_FULLOPEN;
	}
}
Beispiel #2
0
void OneFPModelProcess(WINDOW* win, char* pUserID)
{
    char* pApprovalModel = "";
    int iInputEventIdx;
    bool bFPMatchResult;
    // 首先获取配置信息  远程审批模式
    DB_GetConfigInfo(CONFIG_NAME_APPROVAL_MODEL, &pApprovalModel);

    // 如果开启了远程审批模式
    if(strcmp(pApprovalModel,CONFIG_APPROVAL_MODEL_ON) == 0)
    {
        DEBUG_LOG("远程审批模式 == on");
    }
    
    // 如果没开启远程审批模式
    else
    {
        DEBUG_LOG("远程审批模式 == off");
        /*
        // 等待指纹输入
        iInputEventIdx = WaitForInputEvent();
        switch(iInputEventIdx)
        {
            case INPUT_EVENT_FP:
                    // 输入指纹匹配
                    bFPMatchResult = FP_Match();
                    if(bFPMatchResult)
                    {
                        Door_Open(win);
                    }
                    else
                    {
                        // 匹配错误提示
                        FP_ErrorAlarm(win);
                    }
                    break;
            default:
                    // 返回状态首页
                    DisplayLCD(win, STATUS_PAGE_ONE);
                    break;
        }
        */

        
        // 直接开柜
        Door_Open(win, pUserID);
    }
}
Beispiel #3
0
void TwoFPModelProcess(WINDOW* win, char* pUserID, unsigned char cUserPermission)
{
    char log[80] = "";
    char* pSuperviseModel = ""; 
    char* pApprovalModel = "";
    char* pUser2ID ;
    unsigned char cUser2Permission ;
    bool bFPMatchResult ;

    // 首先获取配置信息  监管开柜模式
    DB_GetConfigInfo(CONFIG_NAME_SUPERVISE_MODEL, &pSuperviseModel);

    // 首先获取配置信息  远程审批模式
    DB_GetConfigInfo(CONFIG_NAME_APPROVAL_MODEL, &pApprovalModel);

RE_FP_MATCH:
    bFPMatchResult = false;
    pUser2ID = NULL;
    cUser2Permission = PERMISSION_NULL;
    // 首先验证第二个人的指纹
    bFPMatchResult = FP_Match_OP(NULL, &pUser2ID);

    // 如果两次验证指纹的编号相同,即同一个人,要求重新验证
    if(bFPMatchResult && (strcmp(pUser2ID, pUserID) == 0))
    {
        DEBUG_LOG("两次验证为同一用户,重新验证");
        if(FP_ErrorAlarm(win)<0)
            goto END;
        goto RE_FP_MATCH;
    }
    // 指纹验证通过,第二人的编号存入 pUser2ID 中
    else if(bFPMatchResult)
    {

        // 指纹错误清零
        FP_ErrorClear();
        DEBUG_LOG("第二个用户指纹匹配成功");
        memset(log,0,sizeof(log));
        sprintf(log,"第二个指纹用户为%s;第一个是%s",pUser2ID, pUserID);
        DEBUG_LOG(log);
        // 如果开启了监管开柜模式
        if(strcmp(pSuperviseModel,CONFIG_SUPERVISE_MODEL_ON) == 0)
        {

            DEBUG_LOG("开启了监管开柜模式");
            // 首先获取第二人的权限, 获取的权限存入 cUser2Permission 中
            DB_GetUserPermission(pUser2ID, &cUser2Permission);

            // 如果两人中包含至少一个拥有监管开柜权限
            if( (cUserPermission & PERMISSION_SUPERVISE_OPEN) || (cUser2Permission & PERMISSION_SUPERVISE_OPEN) )
            {
                DEBUG_LOG("监管开柜模式校验成功");
            }

            // 如果两人都没有监管开柜权限,则开柜失败
            else
            {

                DisplayMoreLCD(win, "      ","  开柜失败    ", "无监管开柜权限","     ");
                DEBUG_LOG("监管开柜模式校验失败");
                return;
            }
        }

        // 如果没有开启监管开柜模式
        else
        {

            DEBUG_LOG("没有开启监管开柜模式");
        }

        // 如果开启了远程审批模式
        if(strcmp(pApprovalModel,CONFIG_APPROVAL_MODEL_ON) == 0)
        {

            DEBUG_LOG("远程审批模式 == on");
        }
        // 如果没有开启远程审批模式,直接开柜
        else
        {

            DEBUG_LOG("远程审批模式 == off");
            Door_Open(win, pUserID);
        }


    }

    // 第二人指纹验证失败, 重新进行验证
    else
    {
        DEBUG_LOG("第二个用户指纹匹配失败");
        if(FP_ErrorAlarm(win)<0)
            goto END;
        FREE(pUser2ID);
        goto RE_FP_MATCH;
    }

END:
    return;

}
Beispiel #4
0
bool Entity_CollisionWithWalls(Entity* ent, World* world)
{
    Box* temp = BoundingBox_CreateTemp(ent);
    Entity* collision_sides[5] = {NULL};
	int collisions_nb[5] = { 0 };

    bool collision = false;
    for (int i = 0; i < Vector_Count(&world->non_null_walls); i++)
	{
	    Entity* wall = (Entity*)Vector_Get(&world->non_null_walls, i);
        if(wall->solid && Entity_CheckVeryClose(ent, wall))
        {
            Direction collision_direction = BoundingBox_CheckCollision(&ent->box, temp, &wall->box);
            if (collision_direction != None)
            {

                collision = true;
                collision_sides[collision_direction] = wall;
                collisions_nb[collision_direction]++;
                ent->collision_direction = collision_direction;

                if(ent->t == Cat_Zombie && ent->zombieC->aggressive &&
                  wall->solid &&
                   (wall->t == Cat_Door || wall->t == Cat_Wall) &&
                   ent->zombieC->attack_timer >= ent->zombieC->attack_delay)
                {
                    Structure_GetAttacked(wall, ent);
                    ent->zombieC->attack_timer = 0;
                }

                if(ent->t == Cat_Player && wall->t == Cat_Door)
                {
                    Door_Open(wall);
                }
            }
        }

	}

    for(int i = 0 ; i < Vector_Count(&world->props_vector) ; i++)
    {
        Entity* prop = (struct Entity*)Vector_Get(&world->props_vector, i);
        if(Entity_CheckVeryClose(ent, prop))
        {
            Direction collision_direction = BoundingBox_CheckCollision(&ent->box, temp, &prop->box);

            if (collision_direction != None)
            {
                if(ent->t == Cat_Zombie && ent->zombieC->attack_timer >= ent->zombieC->attack_delay)
                {
                    Structure_GetAttacked(prop, ent);
                    ent->zombieC->attack_timer = 0;
                }
                collision = true;
                collision_sides[collision_direction] = prop;
                collisions_nb[collision_direction]++;
                ent->collision_direction = collision_direction;
            }
        }
    }

    if(ent->movementC->dy == 0)
    {

        if(collisions_nb[Right] == 1 &&
           ent->movementC->dx > 0 &&
           ent->box.right <= collision_sides[Right]->box.left)
        {
            if(ent->box.top < collision_sides[Right]->box.top)
            {
                ent->movementC->dy = -1;
            }
            else if(ent->box.bottom > collision_sides[Right]->box.bottom)
            {
                ent->movementC->dy = 1;
            }
        }
        else if(collisions_nb[Left] == 1 &&
                ent->movementC->dx < 0 &&
                ent->box.left >= collision_sides[Left]->box.right)
        {
            if(ent->box.top < collision_sides[Left]->box.top)
            {
                ent->movementC->dy = -1;
            }
            else if(ent->box.bottom > collision_sides[Left]->box.bottom)
            {
                ent->movementC->dy = 1;
            }
        }
    }

    if(ent->movementC->dx == 0)
    {
        if(collisions_nb[Top] == 1&& ent->movementC->dy < 0
                && ent->box.top >= collision_sides[Top]->box.bottom)
        {
            if(ent->box.left < collision_sides[Top]->box.left)
            {
                ent->movementC->dx = -1;
            }
            else if(ent->box.right > collision_sides[Top]->box.right)
            {
                ent->movementC->dx = 1;
            }
        }
        else if(collisions_nb[Bottom]  == 1 && ent->movementC->dy > 0
                && ent->box.bottom <= collision_sides[Bottom]->box.top)
        {
            if(ent->box.left < collision_sides[Bottom]->box.left)
            {
                ent->movementC->dx = -1;
            }
            else if(ent->box.right > collision_sides[Bottom]->box.right)
            {
                ent->movementC->dx = 1;
            }
        }
    }



    if (collisions_nb[Bottom] && ent->movementC->dy >= 0)
    {
        ent->movementC->dy = collision_sides[Bottom]->box.top - ent->box.bottom - 1;
    }

    if (collisions_nb[Top] && ent->movementC->dy <= 0)
    {
        ent->movementC->dy = collision_sides[Top]->box.bottom - ent->box.top + 1;
    }



    Box* temp2 = BoundingBox_CreateTemp(ent);


    if (collisions_nb[Right] &&
        BoundingBox_CheckCollision(&ent->box, temp2, &collision_sides[Right]->box) == Right &&
        ent->movementC->dx >= 0)
    {
        ent->movementC->dx = collision_sides[Right]->box.left - ent->box.right - 1;
    }

    if (collisions_nb[Left] &&
        BoundingBox_CheckCollision(&ent->box, temp2, &collision_sides[Left]->box) == Left &&
         ent->movementC->dx <= 0)
    {

        ent->movementC->dx = collision_sides[Left]->box.right - ent->box.left + 1;
    }

    free(temp2);


    if(collisions_nb[Left] > 1 && collisions_nb[Bottom] > 0)
    {
        ent->movementC->dx = collision_sides[Left]->box.right - ent->box.left + 1;
        ent->movementC->dy = collision_sides[Bottom]->box.top - ent->box.bottom - 1;
    }
    if(collisions_nb[Left] > 1 && collisions_nb[Top] > 0)
    {
        ent->movementC->dx = collision_sides[Left]->box.right - ent->box.left + 1;
        ent->movementC->dy = collision_sides[Top]->box.bottom - ent->box.top + 1;
    }
    if(collisions_nb[Right] > 1 && collisions_nb[Bottom] > 0)
    {
        ent->movementC->dx = collision_sides[Right]->box.left - ent->box.right - 1;
        ent->movementC->dy = collision_sides[Bottom]->box.top - ent->box.bottom - 1;
    }
    if(collisions_nb[Right] > 1 && collisions_nb[Top] > 0)
    {
        ent->movementC->dx = collision_sides[Right]->box.left - ent->box.right - 1;
        ent->movementC->dy = collision_sides[Top]->box.bottom - ent->box.top + 1;
    }






	free(temp);

	return collision;
}