// ***************************************************************************
// Function:    Cleanup
// Description: Our '/cleanup' command
//              Sends i, esc, esc, esc, esc, i
// Usage:       /cleanup
// ***************************************************************************
VOID Cleanup(PSPAWNINFO pChar, PCHAR szLine)
{
    DebugSpewNoFile("Cleanup - Cleaning up screen");
    DWORD i;
    KeyCombo Escape;
    ParseKeyCombo("Esc",Escape);
    if(ppContainerMgr && pContainerMgr) {
        PEQ_CONTAINERWND_MANAGER ContainerMgr = (PEQ_CONTAINERWND_MANAGER)pContainerMgr;
        DWORD concount=2; //Close inv + clear target
        if (ContainerMgr->pWorldContents && ContainerMgr->pWorldContents->Open==1) concount++;
        for (i=0;i<25;i++) {
            if (ContainerMgr->pPCContainers[i] && ContainerMgr->pPCContainers[i]->Wnd.dShow==1) concount++;
        }
        for (i=0;i<concount;i++) 
        {
            MQ2HandleKeyDown(Escape);
            MQ2HandleKeyUp(Escape);
        }
        if (!ppInventoryWnd) {
            PCSIDLWND pInvWindow = (PCSIDLWND)pInventoryWnd;
            if (pInvWindow && pInvWindow->dShow==0) 
                DoMappable(pChar,"inventory");
        }
    } else {
        DoMappable(pChar,"inventory");
        for (i=0;i<10;i++) 
        {
            MQ2HandleKeyDown(Escape);
            MQ2HandleKeyUp(Escape);
        }
        DoMappable(pChar,"inventory");
    }
}
Esempio n. 2
0
//EQLIB_API VOID DoMappable(PSPAWNINFO pChar, PCHAR szLine)
int CMD_Keypress(int argc, char *argv[])
{
	if (argc<2)
	{
		WriteChatf("Syntax: %s <eqcommand|keycombo> [hold|chat]",argv[0]);
		return 0;
	}
	bool bHold=false;
	bool bChat=false;
	if (argc==3)
	{
		if (!stricmp(argv[2],"hold"))
		{
			bHold=true;
		}
		else if (!stricmp(argv[2],"chat"))
		{
			bChat=true;
		}
	}
	if (!PressMQ2KeyBind(argv[1],bHold))
	{
		int N=FindMappableCommand(argv[1]);
		if (N>=0)
		{
			ExecuteCmd(N,1,0);
			if (!bHold)
				ExecuteCmd(N,0,0);
			return 0;
		}
		KeyCombo Temp;
		if (ParseKeyCombo(argv[1],Temp))
		{
			if (bChat)
			{
				pWndMgr->HandleKeyboardMsg(Temp.Data[3],1);
				pWndMgr->HandleKeyboardMsg(Temp.Data[3],0);
			}
			else
			{
				MQ2HandleKeyDown(Temp);
				if (!bHold)
					MQ2HandleKeyUp(Temp);
			}
			return 0;
		}

		WriteChatf("Invalid mappable command or key combo '%s'",argv[1]);
		return -1;
	}
	return 0;
}
// ***************************************************************************
// Function:    EndMacro
// Description: Our '/endmacro' command
// Usage:       /endmacro
// ***************************************************************************
VOID EndMacro(PSPAWNINFO pChar, PCHAR szLine)
{
    CHAR Buffer[MAX_STRING] = {0};
    DWORD i;
    PMACROBLOCK pPrev;
    PMACROSTACK pStack;
    PEVENTQUEUE pEvent;
    PEVENTLIST pEventL;
    BOOL bKeepKeys = gKeepKeys;
    if (szLine[0]!=0) {
        GetArg(Buffer,szLine,1);
        szLine = GetNextArg(szLine);
        if (stricmp(Buffer,"keep")) {
            SyntaxError("Usage: /endmacro [keep keys]");
            return;
        }
        while (szLine[0]!=0) {
            GetArg(Buffer,szLine,1);
            szLine = GetNextArg(szLine);
            if (!stricmp(Buffer,"keys")) bKeepKeys = TRUE;
        }
    }

    if (!gMacroBlock) {
        MacroError("Cannot end a macro when one isn't running.");
        return;
    }

    /////////////// 
    // Code allowing for a routine for "OnExit"
    while (gMacroBlock->pNext) 
    {
        gMacroBlock=gMacroBlock->pNext;
        //DebugSpew("%s",gMacroBlock->Line);
        if (!stricmp(":OnExit",gMacroBlock->Line)) 
        {
            if (gReturn)            // return to the macro the first time around
            {
                gReturn = false;    // We don't want to return the 2nd time.
                return;
            }
            else
                break;
        }
    }
    gReturn = true;            // reset for next time
    //
    ///////////////

#ifdef MQ2_PROFILING
    // How many performance counters in 1 second?
    LARGE_INTEGER PerformanceFrequency;
    QueryPerformanceCounter(&PerformanceFrequency);

    // Move to first macro line
    while (gMacroBlock->pPrev) gMacroBlock = gMacroBlock->pPrev;

    CHAR Filename[MAX_STRING] = {0};
    FILE *fMacro = NULL;
    while (gMacroBlock) {
        // Is this a different macro file?
        if (strcmp(Filename, gMacroBlock->SourceFile)) {
            // Close existing file
            if (fMacro) {
                fclose(fMacro);
            }
            // Open new profiling log file
            strcpy(Filename, gMacroBlock->SourceFile);
            sprintf(Buffer, "%s\\%s.mqp", gszMacroPath, Filename);
            fMacro = fopen(Buffer, "w");
            if (fMacro) {
                fprintf(fMacro, " Execute |  Total   | Avg uSec | Line | Macro Source Code\n");
                fprintf(fMacro, " Count   |   uSec   | Per 1000 |\n");
                fprintf(fMacro, "------------------------------------------------------------------------------------------------------------- \n");
            }
        }

        // Log execution/profiling information.  Output format is:
        // Execution Count | Microseconds | Line # | Macro Source
        if (fMacro) {
            DWORD count = gMacroBlock->ExecutionCount;
            DWORD total = (DWORD)(gMacroBlock->ExecutionTime * 1000000 / PerformanceFrequency.QuadPart);
            DWORD avg = 0;
            if (count > 0) {
                avg = total * 1000 / count;
            }
            fprintf(fMacro, "%8lu | %8lu | %8lu | %4lu | %s\n",
                count,
                total,
                avg,
                gMacroBlock->LineNumber,
                gMacroBlock->Line);
        }

        // Terminate on last macro line
        if (gMacroBlock->pNext) {
            gMacroBlock = gMacroBlock->pNext;
        } else {
            break;
        }
    }
    // Close existing file
    if (fMacro) {
        fclose(fMacro);
    }
#endif

    while (gMacroBlock->pNext) gMacroBlock=gMacroBlock->pNext;
    while (gMacroBlock) {
        pPrev = gMacroBlock->pPrev;
        free(gMacroBlock);
        gMacroBlock = pPrev;
    }
    while (gMacroStack) {
        pStack = gMacroStack->pNext;
        if (gMacroStack->LocalVariables) 
            ClearMQ2DataVariables(&gMacroStack->LocalVariables);
        if (gMacroStack->Parameters) 
            ClearMQ2DataVariables(&gMacroStack->Parameters);
        free(gMacroStack);
        gMacroStack = pStack;
    }
    gMacroSubLookupMap.clear(); 
    while (gEventQueue) {
        pEvent = gEventQueue->pNext;
        free(gEventQueue);
        gEventQueue = pEvent;
    }
    while (pEventList) {
        pEventL = pEventList->pNext;
        free(pEventList);
        pEventList = pEventL;
    }
#ifdef USEBLECHEVENTS
    pEventBlech->Reset();
#endif
    for  (i=0;i<NUM_EVENTS;i++) {
        gEventFunc[i]=NULL;
    }

    gMacroPause = FALSE;
    gEventChat=0;
    gFaceAngle=10000.0f;
    gLookAngle=10000.0f;
    gDelay = 0;
    gTurbo = FALSE;
    pDoorTarget = NULL;
#ifdef ISXEQ_LEGACY
    char ShortName[128];
    ShortName[0]=0;
    _splitpath(gszMacroName,0,0,ShortName,0);
    IS_ScriptEngineScriptEnds(pExtension,pISInterface,hScriptEngineService,&g_LegacyEngine,ShortName);
#endif

    gszMacroName[0]=0;
    gRunning = 0;

    if (!bKeepKeys) {
        KeyCombo TempCombo;
        for (i=0;gDiKeyID[i].szName[0];i++) 
        {
            TempCombo.Data[3]=(unsigned char)gDiKeyID[i].Id;
            MQ2HandleKeyUp(TempCombo);
        }
    }

    ClearMQ2DataVariables(&pMacroVariables);

    DebugSpewNoFile("EndMacro - Ended");
    if (gFilterMacro != FILTERMACRO_NONE && gFilterMacro != FILTERMACRO_MACROENDED)
        WriteChatColor("The current macro has ended.",USERCOLOR_DEFAULT);
}