• 电梯调度系统(界面由C图形库编绘)


    1.编程题目

    电梯调度系统

    2.结对编程组员

    黄冠译,刘畅

    3.编程语言

    C语言图形库

    4题目要求

    编写人员:刘畅,黄冠译

    代码如下:

    # include <stdio.h>
    # include <graphics.h>
    # include <conio.h>
    # include <time.h>
    # include <memory.h>
    
    int x[4] = {570,570,570,570},k[4]={0,0,0,0},t[4]={0,0,0,0},di[4]={0,0,0,0};
    int cro,col;
    char s[10];
    int refresh_rate = 10;                                                                            //刷新率定义大小
    MOUSEMSG M;
    IMAGE ima,ima1,ima2,back,block;
    
    struct elevator                                                                                    //定义4个电梯结构体数组
    {
        int num,msum,dir,flo,mflo,numm,summ,elein[21],eleof[21],peom[21];
    }ele[5]={{0,0,2,1,1,10,800},{0,0,2,1,1,10,800},{0,0,2,1,1,20,1600},{0,0,2,1,1,20,2000}};
    
    struct floors                                                                                    //定义21个楼层结构体数组
    {
        int num[3],go,emin;
    }floor[21];
    
    void Draw1(int e)                                                                                //电梯接人路线绘制函数
    {
        if(t[e]==0)                                                                    //如果电梯没有到达目的楼层,则继续绘制路线
        {
            if (ele[e].dir==0)                                                //电梯上楼绘制
            {
                putimage(140+e*100,(20-ele[e].flo)*30-k[e],&ima);
                k[e]++;
                if (k[e]==30)
                {
                    ele[e].flo++;
                    k[e]=0;
                }
            }
            if (ele[e].dir==1)                                                //电梯下楼绘制
            {
                putimage(140+e*100,(20-ele[e].flo)*30+k[e],&ima);
                k[e]++;
                if (k[e]==30)
                {
                    ele[e].flo--;
                    k[e]=0;
                }
            }
            if (ele[e].dir==2)                                                //电梯停歇状态绘制
                putimage(140+e*100,(20-ele[e].flo)*30,&ima);
            if ((ele[e].flo==ele[e].mflo)&&(ele[e].dir!=2))                    //电梯到达目的楼层后的数值重新赋值
            {
                int h;
                ele[e].dir=2;
                floor[ele[e].flo].emin=22;
                t[e]=60;
                k[e]=0;
                while (floor[ele[e].mflo].num[0]!=0)                        //接人后电梯内部状态赋值
                {
                    h=rand()%41+50;
                    if ((ele[e].num+1<=ele[e].numm)&&(ele[e].msum+h<=ele[e].summ))
                    {
                        ele[e].num++;
                        ele[e].peom[ele[e].num-1]=h;
                        ele[e].msum=ele[e].msum+h;
                        floor[ele[e].flo].num[0]--;
                    }
                    else
                        break;
                }
                while (floor[ele[e].mflo].num[1]!=0)
                {
                    h=rand()%41+50;
                    if ((ele[e].num+1<=ele[e].numm)&&(ele[e].msum+h<=ele[e].summ))
                    {
                        ele[e].num++;
                        ele[e].peom[ele[e].num-1]=h;
                        ele[e].msum=ele[e].msum+h;
                        floor[ele[e].flo].num[1]--;
                    }
                    else
                        break;
                }
            }
        }
        if (t[e]!=0)                                                                //如果电梯到达目的楼层,则绘制电梯开门关门状态
        {
            if (t[e]>50)                                                    //开门
            {
                putimage(140+e*100-60+t[e]+5,(20-ele[e].flo)*30,&ima1);
                putimage(140+e*100+60-t[e]+5,(20-ele[e].flo)*30,&ima2);
                t[e]--;
            }
            else if (t[e]>10)
            {
                putimage(140+e*100-10+5,(20-ele[e].flo)*30,&ima1);
                putimage(140+e*100+11+5,(20-ele[e].flo)*30,&ima2);
                t[e]--;
            }
            else if (t[e]>0)                                                //关门
            {
                putimage(140+e*100-t[e]+5,(20-ele[e].flo)*30,&ima1);
                putimage(140+e*100+t[e]+5,(20-ele[e].flo)*30,&ima2);
                t[e]--;
            }
        }
    }
    
    void Draw2(int e)                                                                                //电梯接人结束后,进入送客绘制模式
    {
        for (int v=0;v<=20;v++)                                                            //电梯内部按钮绘制
        {
            if ((v==0)&&(ele[e].elein[v]==1))
                putimage(528+20%5*55,47+20/5*19.3+e*150,&block);
            else if (ele[e].elein[v]==1)
                putimage(528+(v-1)%5*55,47+(v-1)/5*19+e*150,&block);
        }
        if(t[e]==0)                                                                        //如果电梯没有到达目的楼层,则继续绘制路线
        {    
            if (ele[e].dir==0)                                                    //电梯上楼绘制
            {
                putimage(140+e*100,(20-ele[e].flo)*30-k[e],&ima);
                k[e]++;
                if (k[e]==30)
                {
                    ele[e].flo++;
                    k[e]=0;
                }
            }
            if (ele[e].dir==1)                                                    //电梯下楼绘制
            {
                putimage(140+e*100,(20-ele[e].flo)*30+k[e],&ima);
                k[e]++;
                if (k[e]==30)
                {
                    ele[e].flo--;
                    k[e]=0;
                }
            }
            if (ele[e].flo==ele[e].mflo)                                        //到达目的楼层后绘制
            {
                ele[e].elein[ele[e].flo]=0;
                di[e]=0;
                for (int v=0;v<=20;v++)
                    if (ele[e].elein[v]==1)
                        di[e]=1;
                k[e]=0;
                ele[e].dir=2;
                while(ele[e].eleof[ele[e].flo]!=0)                                //电梯下人操作,重新赋值
                {
                    ele[e].num--;
                    ele[e].msum=ele[e].msum-ele[e].peom[ele[e].num];
                    ele[e].eleof[ele[e].flo]--;
                    if (ele[e].num==0)
                        break;
                }
                t[e]=60;
            }
        }
        if (t[e]!=0)                                                                //如果电梯到达目的楼层,则绘制电梯开门关门状态                                                            
        {
            if (t[e]>50)                                                    //开门
            {
                putimage(140+e*100-60+t[e]+5,(20-ele[e].flo)*30,&ima1);
                putimage(140+e*100+60-t[e]+5,(20-ele[e].flo)*30,&ima2);
                t[e]--;
            }
            else if (t[e]>10)
            {
                putimage(140+e*100-10+5,(20-ele[e].flo)*30,&ima1);
                putimage(140+e*100+10+5,(20-ele[e].flo)*30,&ima2);
                t[e]--;
            }
            else if (t[e]>0)                                                //关门
            {
                putimage(140+e*100-t[e]+5,(20-ele[e].flo)*30,&ima1);
                putimage(140+e*100+t[e]+5,(20-ele[e].flo)*30,&ima2);
                t[e]--;
            }
        }
    }
    
    void run ()                                                                                        //电梯运行总调度函数                                                                        
    {    
        int o,p,mine;
        setcolor(BLACK);
        while(1)                                                                            //电梯运行状态循环
        { 
            if(MouseHit())                                                            //如果触发鼠标时间
            {
                M = GetMouseMsg();                                                //鼠标事件获取
                if (M.uMsg == WM_LBUTTONDOWN)                                    //如果鼠标左键单击
                {
                    if (M.x>=5&&M.x<=24)                                        //判断鼠标指针所在范围是否上楼
                    {
                        o=20-(M.y+1)/30;
                        InputBox(s, 10, "请输入进电梯的人数");                    //弹窗响应,要求输入
                        sscanf(s,"%d",&p);
                        floor[o].num[0]=p;
                    }
                    if (M.x>=25&&M.x<=45)                                        //判断鼠标指针所在范围是否下楼
                    {
                        o=20-(M.y+1)/30;
                        InputBox(s, 10, "请输入进电梯的人数");                    //弹窗响应,要求输入
                        sscanf(s,"%d",&p);
                        floor[o].num[1]=p;
                    }
                    if ((ele[0].num!=0)&&(M.x>=527&&M.x<=801&&M.y>=46&&M.y<=142))        //判断电梯内部按钮是否由鼠标响应
                    {
                        int r;
                        cro=(M.x-528)/55;
                        col=(M.y-46)/20;
                        r=cro+col*5+1;
                        if (r==21)
                            r=0;
                        di[0]=1;
                        ele[0].mflo=r;
                        ele[0].elein[ele[0].mflo]=1;
                        InputBox(s, 10, "请输入此楼层要下电梯的人数");                    //弹窗响应,要求输入
                        sscanf(s,"%d",&p);
                        ele[0].eleof[ele[0].mflo]=p;
                    }
                    if ((ele[1].num!=0)&&(M.x>=527&&M.x<=801&&M.y>=196&&M.y<=292))        //判断电梯内部按钮是否由鼠标响应
                    {
                        int r;
                        cro=(M.x-528)/55;
                        col=(M.y-197)/20;
                        r=cro+col*5+1;
                        if (r==21)
                            r=0;
                        if (r%2==1)
                        {
                            di[1]=1;
                            ele[1].mflo=r;
                            ele[1].elein[ele[1].mflo]=1;
                            InputBox(s, 10, "请输入此楼层要下电梯的人数");                //弹窗响应,要求输入
                            sscanf(s,"%d",&p);
                            ele[1].eleof[ele[1].mflo]=p;
                        }
                    }
                    if ((ele[2].num!=0)&&(M.x>=527&&M.x<=801&&M.y>=346&&M.y<=442))        //判断电梯内部按钮是否由鼠标响应
                    {
                        int r;
                        cro=(M.x-528)/55;
                        col=(M.y-346)/20;
                        r=cro+col*5+1;
                        if (r==21)
                            r=0;
                        if (r%2==0)
                        {
                            di[2]=1;
                            ele[2].mflo=r;
                            ele[2].elein[ele[2].mflo]=1;
                            InputBox(s, 10, "请输入此楼层要下电梯的人数");                //弹窗响应,要求输入
                            sscanf(s,"%d",&p);
                            ele[2].eleof[ele[2].mflo]=p;
                        }
                    }
                    if ((ele[3].num!=0)&&(M.x>=527&&M.x<=801&&M.y>=496&&M.y<=592))        //判断电梯内部按钮是否由鼠标响应
                    {
                        int r;
                        cro=(M.x-528)/55;
                        col=(M.y-496)/20;
                        r=cro+col*5+1;
                        if (r==21)
                            r=0;
                        di[3]=1;
                        ele[3].mflo=r;
                        ele[3].elein[ele[3].mflo]=1;
                        InputBox(s, 10, "请输入此楼层要下电梯的人数");                    //弹窗响应,要求输入
                        sscanf(s,"%d",&p);
                        ele[3].eleof[ele[3].mflo]=p;
                    }
                }
            }
            for(int j=20;j>=0;j--)                                                        //每个楼层开始判断是否有客人要上电梯的响应
            {
                mine=4;
                if (floor[j].num[0]!=0)                                                //有上电梯响应且客人要上楼,开始电梯调度
                {
                    if ((ele[0].num<10)&&(ele[0].msum<800))                        //1号电梯条件是否满足
                    {
                        if ((j>=ele[0].flo)&&(ele[0].dir!=1))
                            if (floor[j].emin>(j-ele[0].flo))
                            {
                                floor[j].emin=j-ele[0].flo;
                                mine=0;
                            }
                        if ((j<ele[0].flo)&&(ele[0].dir==2))
                            if (floor[j].emin>(ele[0].flo-j))
                            {
                                floor[j].emin=ele[0].flo-j;
                                mine=0;
                            }
                    }
                    if ((ele[3].num<20)&&(ele[3].msum<2000))                    //4号电梯条件是否满足
                    {
                        if ((j>=ele[3].flo)&&(ele[3].dir!=1))
                            if (floor[j].emin>(j-ele[3].flo))
                            {
                                floor[j].emin=j-ele[3].flo;
                                mine=3;
                            }
                        if ((j<ele[3].flo)&&(ele[3].dir==2))
                            if (floor[j].emin>(ele[3].flo-j))
                            {
                                floor[j].emin=ele[3].flo-j;
                                mine=3;
                            }
                    }
                    if (j%2==0)
                    {
                        if ((ele[2].num<20)&&(ele[2].msum<1600))                //3号电梯条件是否满足
                        {
                            if ((j>=ele[2].flo)&&(ele[2].dir!=1))
                                if (floor[j].emin>(j-ele[2].flo))
                                {
                                    floor[j].emin=j-ele[2].flo;
                                    mine=2;
                                }
                            if ((j<ele[2].flo)&&(ele[2].dir==2))
                                if (floor[j].emin>(ele[2].flo-j))
                                {
                                    floor[j].emin=ele[2].flo-j;
                                    mine=2;
                                }
                        }
                    }
                    if (j%2==1)                                                    //2号电梯条件是否满足
                    {
                        if ((ele[1].num<10)&&(ele[1].msum<800))
                        {
                            if ((j>=ele[1].flo)&&(ele[1].dir!=1))
                                if (floor[j].emin>(j-ele[1].flo))
                                {
                                    floor[j].emin=j-ele[1].flo;
                                    mine=1;
                                }
                            if ((j<ele[1].flo)&&(ele[1].dir==2))
                                if (floor[j].emin>(ele[1].flo-j))
                                {
                                    floor[j].emin=ele[1].flo-j;
                                    mine=1;
                                }
                        }
                    }
                    if (j>=ele[mine].flo)                                        //用距离判断满足条件的电梯,在此筛选出满足条件电梯
                        ele[mine].dir=0;
                    else
                        ele[mine].dir=1;                                        //满足条件的电梯设置目的楼层
                    ele[mine].mflo=j;
                }
                if (floor[j].num[1]!=0)                                                //有上电梯响应且客人要下楼,开始电梯调度    
                {
                    if ((ele[0].num<10)&&(ele[0].msum<800))
                    {
                        if ((j<=ele[0].flo)&&(ele[0].dir!=1))
                            if (floor[j].emin>(ele[0].flo-j))
                            {
                                floor[j].emin=ele[0].flo-j;
                                mine=0;
                            }
                        if ((j>ele[0].flo)&&(ele[0].dir==2))
                            if (floor[j].emin>(j-ele[0].flo))
                            {
                                floor[j].emin=j-ele[0].flo;
                                mine=0;
                            }
                    }
                    if ((ele[3].num<20)&&(ele[3].msum<2000))
                    {
                        if ((j<=ele[3].flo)&&(ele[3].dir!=1))
                            if (floor[j].emin>(ele[3].flo-j))
                            {
                                floor[j].emin=ele[3].flo-j;
                                mine=3;
                            }
                        if ((j>ele[3].flo)&&(ele[3].dir==2))
                            if (floor[j].emin>(j-ele[3].flo))
                            {
                                floor[j].emin=j-ele[3].flo;
                                mine=3;
                            }
                    }
                    if (j%2==0)
                    {
                        if ((ele[2].num<20)&&(ele[2].msum<1600))
                        {
                            if ((j<=ele[2].flo)&&(ele[2].dir!=1))
                                if (floor[j].emin>(ele[2].flo-j))
                                {
                                    floor[j].emin=ele[2].flo-j;
                                    mine=2;
                                }
                            if ((j>ele[2].flo)&&(ele[2].dir==2))
                                if (floor[j].emin>(j-ele[2].flo))
                                {
                                    floor[j].emin=j-ele[2].flo;
                                    mine=2;
                                }
                        }
                    }
                    if (j%2==1)
                    {
                        if ((ele[1].num<10)&&(ele[1].msum<800))
                        {
                            if ((j<=ele[1].flo)&&(ele[1].dir!=1))
                                if (floor[j].emin>(ele[1].flo-j))
                                {
                                    floor[j].emin=ele[1].flo-j;
                                    mine=1;
                                }
                            if ((j>ele[1].flo)&&(ele[1].dir==2))
                                if (floor[j].emin>(j-ele[1].flo))
                                {
                                    floor[j].emin=j-ele[1].flo;
                                    mine=1;
                                }
                        }
                    }
                    if (j>=ele[mine].flo)
                        ele[mine].dir=0;
                    else
                        ele[mine].dir=1;
                    ele[mine].mflo=j;    
                }
            }
            BeginBatchDraw();                                                    //开始画图
            putimage(0,0,&back);
            for (int i=0;i<4;i++)                                            //四个电梯一次绘制当前状态
            {
                if (di[i]==0)                                            //接客的电梯绘制
                    Draw1(i);
                if (di[i]==1)                                            //送客的电梯绘制
                {
                    if (ele[i].mflo>=ele[i].flo)                        //上楼绘制
                    {
                        ele[i].dir=0;
                        for (int w=ele[i].flo;w<=20;w++)
                        {
                            if (ele[i].elein[w]==1)
                            {
                                ele[i].mflo=w;
                                break;
                            }
                        }
                    }
                    else                                                //下楼绘制
                    {
                        ele[i].dir=1;
                        for (int w=ele[i].flo;w>=0;w--)
                        {
                            if (ele[i].elein[w]==1)
                            {
                                ele[i].mflo=w;
                                break;
                            }
                        }
                    }
                    Draw2(i);
                }
                setbkmode(TRANSPARENT);                                    //输出电梯当前状态数值
                sprintf(s,"%d",ele[i].num);                                //电梯当前人数
                outtextxy(890,49+i*150,s);
                sprintf(s,"%d",ele[i].msum);                            //电梯当前重量
                outtextxy(890,74+i*150,s);
                sprintf(s,"%d",ele[i].flo);                                //电梯当前楼层
                outtextxy(890,99+i*150,s);    
            }
            EndBatchDraw();                                        //结束绘制
            Sleep(refresh_rate);                            //延时绘制,否则会本次绘制会遮挡下一次绘制
        }
        
    }
    
    void main()                                                                    //主函数
    {    
        for (int i=0;i<21;i++)                                            //初始化
        {
            floor[i].num[0]=0;
            floor[i].num[1]=0;
            floor[i].emin=22;
        }
        initgraph(1000,630);                                            //构建窗口大小
        loadimage(&back,"pic//2.jpg");                                    //载入图片2
        putimage(0,0,&back);
        loadimage(&ima,"pic//1.jpg");                                    //载入图片1            
        loadimage(&ima1,"pic//3.jpg");                                    //载入图片3
        loadimage(&ima2,"pic//4.jpg");                                    //载入图片4
        loadimage(&block,"pic//5.jpg");                                    //载入图片5
        BeginBatchDraw();                                                //初始化绘制
        for (int j=0;j<4;j++)
            putimage(140+j*100,(20-ele[j].flo)*30 ,&ima);
        EndBatchDraw();                                                    //结束绘制
        run();                                                            //进入电梯调度函数开始电梯总调度
        closegraph();                                                //关闭窗口
    }

    我队友真的太厉害了,编程能力真的是太强大了,经过这俩周的合作,我在他身上学到了好多在书本上学不到,看不到的知识。对于这次结队编程的总结跟体会我会在下一个博客中详细的说明下面附上我队友的链接http://www.cnblogs.com/hgcrown/p/5364849.html

  • 相关阅读:
    sizeof、strlen、length、size
    extern关键字
    结构
    引用
    指针
    数组
    linux端口 ,打开服务端口
    linux用户禁用
    防止验证码的恶意发送
    springboot 项目windows下打包、注册服务。
  • 原文地址:https://www.cnblogs.com/xueshengliuchang/p/5372333.html
Copyright © 2020-2023  润新知