immibis
/
colobot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Refactoring in tests infrastructure 

* all tests are now in /test/ subdirectory
 * unit tests concatenated to one executable (TODO: ui, common)
 * preparation for test environments (OpenGL and others)
 * removed old TestCBot
dev-ui
Piotr Dziwinski 2013-02-03 20:03:36 +01:00
parent 3f41f97fc4
commit 209c6412ae
126 changed files with 760 additions and 4827 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
CMakeLists.txt
View File

@ -69,7 +69,7 @@ endif()
# Global compile flags
# These are specific to GCC/MinGW/clang; for other compilers, change as necessary
# The flags are used throughout src/ subdir
# The flags are used throughout src/ and test/ subdirs
set(COLOBOT_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wold-style-cast ${CXX11_FLAGS}")
set(COLOBOT_CXX_FLAGS_RELEASE "-O2")
set(COLOBOT_CXX_FLAGS_DEBUG "-g -O0")
@ -151,7 +151,6 @@ endif()
if(${TESTS})
add_definitions(-DTEST_VIRTUAL=virtual)
enable_testing()
else()
add_definitions(-DTEST_VIRTUAL=)
endif()
@ -206,6 +205,11 @@ if(${TESTS})
add_subdirectory(${GMOCK_SRC_DIR} bin/gmock)
endif()
# Tests targets
enable_testing()
add_subdirectory(test bin/test)
endif()
# Installation paths defined before compiling sources

17
src/CBot/tests/CBot_console/CMakeLists.txt
View File

@ -1,17 +0,0 @@
cmake_minimum_required(VERSION 2.8)
project(CBot_console C CXX)
# Build with debugging symbols
if(NOT CMAKE_BUILD_TYPE)
set(CMAKE_BUILD_TYPE debug)
endif(NOT CMAKE_BUILD_TYPE)
# Global compile flags
set(CMAKE_CXX_FLAGS_RELEASE "-O2")
set(CMAKE_CXX_FLAGS_DEBUG "-g -O0")
# Include cmake directory
SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${colobot_SOURCE_DIR}/cmake")
add_subdirectory(src bin)

1
src/CBot/tests/CBot_console/src/CBot
View File

@ -1 +0,0 @@
../../../../CBot/

32
src/CBot/tests/CBot_console/src/CMakeLists.txt
View File

@ -1,32 +0,0 @@
# CBot shared library is built separately
add_subdirectory(CBot)
# Configure options
option(DEBUG "Enable debug output" ON)
set(PLATFORM_LIBS "")
# Source files
# Commented out files are still dependent on DirectX or WinAPI
set(SOURCES
app/CClass.cpp
app/main.cpp
#app/routines.cpp
app/CBotDoc.cpp
app/CBotConsole.cpp
)
set(LIBS
CBot
)
include_directories(. ${CMAKE_CURRENT_BINARY_DIR}
)
link_directories(${CMAKE_CURRENT_SOURCE_DIR}/CBot)
add_executable(CBot_console ${SOURCES})
target_link_libraries(CBot_console ${LIBS})

221
src/CBot/tests/TestCBot/CBotConsoleDlg.cpp
View File

@ -1,221 +0,0 @@
// * This file is part of the COLOBOT source code
// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
// *
// * This program is free software: you can redistribute it and/or modify
// * it under the terms of the GNU General Public License as published by
// * the Free Software Foundation, either version 3 of the License, or
// * (at your option) any later version.
// *
// * This program is distributed in the hope that it will be useful,
// * but WITHOUT ANY WARRANTY; without even the implied warranty of
// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// * GNU General Public License for more details.
// *
// * You should have received a copy of the GNU General Public License
// * along with this program. If not, see http://www.gnu.org/licenses/.
// CBotConsoleDlg.cpp : implementation file
//
#include "stdafx.h"
#include "TestCBot.h"
#include "CBotConsoleDlg.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CBotConsoleDlg dialog
CBotConsoleDlg::CBotConsoleDlg(CWnd* pParent /*=NULL*/)
: CDialog(CBotConsoleDlg::IDD, pParent)
{
//{{AFX_DATA_INIT(CBotConsoleDlg)
// NOTE: the ClassWizard will add member initialization here
//}}AFX_DATA_INIT
m_pProg = NULL;
m_threadinfo.m_bRun = FALSE;
m_code = 0;
}
void CBotConsoleDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CBotConsoleDlg)
DDX_Control(pDX, IDOK, m_cOK);
DDX_Control(pDX, IDC_EDIT2, m_Edit2);
DDX_Control(pDX, IDC_EDIT1, m_Edit1);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CBotConsoleDlg, CDialog)
//{{AFX_MSG_MAP(CBotConsoleDlg)
ON_MESSAGE(WM_ENDPROG, EndProg)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CBotConsoleDlg message handlers
UINT ThreadProc(ThreadInfo *info)
{
CTime t0 = CTime::GetCurrentTime();
int Cpt = 0;
info->m_pProg->Start("LaCommande");
while ( !info->m_bStop && !info->m_pProg->Run() )
{
#if 0
const char* FunctionName;
const char* FN;
int start, end;
info->m_pProg->GetRunPos(FunctionName, start, end);
if ( FunctionName != NULL )
{
info->m_pEditx->SetSel(start, end);
char buffer[200];
sprintf( buffer, "step %s, %d, %d",FunctionName, start, end);
AfxMessageBox( buffer );
int level = 0;
do
{
CBotVar* t = info->m_pProg->GivStackVars(FN, level--);
if ( FN != FunctionName ) break;
if ( t != NULL )
{
CString s ;
while ( t != NULL )
{
if (s.IsEmpty()) s+= "Stack -> ";
else s+= " , ";
s += t->GivValString();
t = t->GivNext();
}
AfxMessageBox(s);
}
} while (TRUE);
}
#endif
Cpt++;
if ( Cpt%50 == 0 ) info->m_pEdit1->ReplaceSel(".");
}
if ( info->m_bStop )
{
info->m_pEdit1->ReplaceSel("\r\nInterrompu\r\n");
}
else if (info->m_pProg->GivError() == 0)
{
CTime t = CTime::GetCurrentTime();
CTimeSpan ts = t - t0;
char buffer[200];
sprintf( buffer, "\r\nExécution terminée en %d secondes.\r\nInterrompue %d fois.\r\n",
ts.GetTotalSeconds(), Cpt);
info->m_pEdit1->ReplaceSel(buffer);
}
info->m_pWndMessage->SendMessage(WM_ENDPROG, 0, 0) ;
return 0 ;
}
LONG CBotConsoleDlg::EndProg(UINT wparam, LONG lparam)
{
m_threadinfo.m_bRun = FALSE;
if (m_pProg->GetError(m_code, m_start, m_end))
{
CBotString TextError;
TextError = CBotProgram::GivErrorText(m_code);
AfxMessageBox(TextError);
CDialog::OnCancel();
return 1;
}
delete m_pProg;
m_pProg = NULL;
m_Edit2.EnableWindow(TRUE);
m_cOK.EnableWindow(TRUE);
m_Edit2.SetWindowText("");
m_Edit2.SetFocus();
return 0 ;
}
void CBotConsoleDlg::OnOK()
{
CTestCBotApp* pApp = (CTestCBotApp*)AfxGetApp();
pApp->m_pConsole = &m_Edit1;
m_code = 0;
CString Commande;
m_Edit2.GetWindowText(Commande);
CString s = "void LaCommande() { " + Commande + " ;}";
m_pProg = new CBotProgram();
CBotStringArray liste;
m_pProg->Compile(s, liste);
int err, start, end;
if ( m_pProg->GetError(err, start, end) )
{
CBotString TextError;
TextError = CBotProgram::GivErrorText(err);
AfxMessageBox(TextError);
m_Edit2.SetSel(start-20, end-20);
return;
}
m_Edit1.ReplaceSel("\r\n" + Commande + " ->\r\n");
m_Edit2.SetWindowText("");
m_Edit1.SetFocus();
m_Edit2.EnableWindow(FALSE);
m_cOK.EnableWindow(FALSE);
// lance un processus paralèle pour l'exécution
m_threadinfo.m_pWndMessage = this ;
m_threadinfo.m_pEdit1 = &m_Edit1;
m_threadinfo.m_pEditx = m_pEditx;
m_threadinfo.m_pProg = m_pProg;
m_threadinfo.m_bStop = FALSE;
m_threadinfo.m_bRun = TRUE;
AfxBeginThread((AFX_THREADPROC)ThreadProc, &m_threadinfo) ;
}
void CBotConsoleDlg::OnCancel()
{
if (!m_threadinfo.m_bRun) CDialog::OnCancel();
m_threadinfo.m_bStop = TRUE ;
}
BOOL CBotConsoleDlg::OnInitDialog()
{
CDialog::OnInitDialog();
m_Edit1.ReplaceSel("Les fonctions suivantes sont disponibles:\r\n");
for ( int i = 0; i < m_pListe->GivSize(); i++ )
{
CBotString x = (*m_pListe)[i] + CBotString("\r\n");
m_Edit1.ReplaceSel(x);
}
m_Edit1.ReplaceSel("Entrez une commande ci-dessous.\r\n\r\n");
return TRUE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
}

85
src/CBot/tests/TestCBot/CBotConsoleDlg.h
View File

@ -1,85 +0,0 @@
// * This file is part of the COLOBOT source code
// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
// *
// * This program is free software: you can redistribute it and/or modify
// * it under the terms of the GNU General Public License as published by
// * the Free Software Foundation, either version 3 of the License, or
// * (at your option) any later version.
// *
// * This program is distributed in the hope that it will be useful,
// * but WITHOUT ANY WARRANTY; without even the implied warranty of
// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// * GNU General Public License for more details.
// *
// * You should have received a copy of the GNU General Public License
// * along with this program. If not, see http://www.gnu.org/licenses/.
#if !defined(AFX_BOTCONSOLEDLG_H__A11450A2_8E09_11D4_A439_00D059085115__INCLUDED_)
#define AFX_BOTCONSOLEDLG_H__A11450A2_8E09_11D4_A439_00D059085115__INCLUDED_
#if _MSC_VER >= 1000
#pragma once
#endif // _MSC_VER >= 1000
// CBotConsoleDlg.h : header file
//
struct ThreadInfo
{
CEdit* m_pEdit1 ;
CEdit* m_pEditx ;
CBotProgram* m_pProg;
CWnd* m_pWndMessage;
BOOL m_bStop;
BOOL m_bRun;
};
/////////////////////////////////////////////////////////////////////////////
// CBotConsoleDlg dialog
class CBotConsoleDlg : public CDialog
{
// Construction
public:
CBotConsoleDlg(CWnd* pParent = NULL); // standard constructor
// Dialog Data
//{{AFX_DATA(CBotConsoleDlg)
enum { IDD = IDD_CONSOLE };
CButton m_cOK;
CEdit m_Edit2;
CEdit m_Edit1;
//}}AFX_DATA
CBotProgram* m_pProg;
ThreadInfo m_threadinfo;
CBotStringArray*
m_pListe;
int m_code, m_start, m_end;
CEdit* m_pEditx;
// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CBotConsoleDlg)
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
//}}AFX_VIRTUAL
// Implementation
protected:
// Generated message map functions
//{{AFX_MSG(CBotConsoleDlg)
virtual void OnOK();
virtual void OnCancel();
virtual BOOL OnInitDialog();
afx_msg LONG EndProg(UINT wparam, LONG lparam) ;
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
//{{AFX_INSERT_LOCATION}}
// Microsoft Developer Studio will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_BOTCONSOLEDLG_H__A11450A2_8E09_11D4_A439_00D059085115__INCLUDED_)

74
src/CBot/tests/TestCBot/ChildFrm.cpp
View File

@ -1,74 +0,0 @@
// * This file is part of the COLOBOT source code
// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
// *
// * This program is free software: you can redistribute it and/or modify
// * it under the terms of the GNU General Public License as published by
// * the Free Software Foundation, either version 3 of the License, or
// * (at your option) any later version.
// *
// * This program is distributed in the hope that it will be useful,
// * but WITHOUT ANY WARRANTY; without even the implied warranty of
// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// * GNU General Public License for more details.
// *
// * You should have received a copy of the GNU General Public License
// * along with this program. If not, see http://www.gnu.org/licenses/.
// ChildFrm.cpp : implementation of the CChildFrame class
//
#include "stdafx.h"
#include "TestCBot.h"
#include "ChildFrm.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CChildFrame
IMPLEMENT_DYNCREATE(CChildFrame, CMDIChildWnd)
BEGIN_MESSAGE_MAP(CChildFrame, CMDIChildWnd)
//{{AFX_MSG_MAP(CChildFrame)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CChildFrame construction/destruction
CChildFrame::CChildFrame()
{
}
CChildFrame::~CChildFrame()
{
}
BOOL CChildFrame::PreCreateWindow(CREATESTRUCT& cs)
{
return CMDIChildWnd::PreCreateWindow(cs);
}
/////////////////////////////////////////////////////////////////////////////
// CChildFrame diagnostics
#ifdef _DEBUG
void CChildFrame::AssertValid() const
{
CMDIChildWnd::AssertValid();
}
void CChildFrame::Dump(CDumpContext& dc) const
{
CMDIChildWnd::Dump(dc);
}
#endif //_DEBUG
/////////////////////////////////////////////////////////////////////////////
// CChildFrame message handlers

66
src/CBot/tests/TestCBot/ChildFrm.h
View File

@ -1,66 +0,0 @@
// * This file is part of the COLOBOT source code
// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
// *
// * This program is free software: you can redistribute it and/or modify
// * it under the terms of the GNU General Public License as published by
// * the Free Software Foundation, either version 3 of the License, or
// * (at your option) any later version.
// *
// * This program is distributed in the hope that it will be useful,
// * but WITHOUT ANY WARRANTY; without even the implied warranty of
// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// * GNU General Public License for more details.
// *
// * You should have received a copy of the GNU General Public License
// * along with this program. If not, see http://www.gnu.org/licenses/.
// ChildFrm.h : interface of the CChildFrame class
//
/////////////////////////////////////////////////////////////////////////////
#if !defined(AFX_CHILDFRM_H__4D1BB909_8E74_11D4_A439_00D059085115__INCLUDED_)
#define AFX_CHILDFRM_H__4D1BB909_8E74_11D4_A439_00D059085115__INCLUDED_
#if _MSC_VER >= 1000
#pragma once
#endif // _MSC_VER >= 1000
class CChildFrame : public CMDIChildWnd
{
DECLARE_DYNCREATE(CChildFrame)
public:
CChildFrame();
// Attributes
public:
// Operations
public:
// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CChildFrame)
virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
//}}AFX_VIRTUAL
// Implementation
public:
virtual ~CChildFrame();
#ifdef _DEBUG
virtual void AssertValid() const;
virtual void Dump(CDumpContext& dc) const;
#endif
// Generated message map functions
protected:
//{{AFX_MSG(CChildFrame)
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
/////////////////////////////////////////////////////////////////////////////
//{{AFX_INSERT_LOCATION}}
// Microsoft Developer Studio will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_CHILDFRM_H__4D1BB909_8E74_11D4_A439_00D059085115__INCLUDED_)

116
src/CBot/tests/TestCBot/MainFrm.cpp
View File

@ -1,116 +0,0 @@
// * This file is part of the COLOBOT source code
// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
// *
// * This program is free software: you can redistribute it and/or modify
// * it under the terms of the GNU General Public License as published by
// * the Free Software Foundation, either version 3 of the License, or
// * (at your option) any later version.
// *
// * This program is distributed in the hope that it will be useful,
// * but WITHOUT ANY WARRANTY; without even the implied warranty of
// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// * GNU General Public License for more details.
// *
// * You should have received a copy of the GNU General Public License
// * along with this program. If not, see http://www.gnu.org/licenses/.
// MainFrm.cpp : implementation of the CMainFrame class
//
#include "stdafx.h"
#include "TestCBot.h"
#include "MainFrm.h"
#include "TestCBotDoc.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CMainFrame
IMPLEMENT_DYNAMIC(CMainFrame, CMDIFrameWnd)
BEGIN_MESSAGE_MAP(CMainFrame, CMDIFrameWnd)
//{{AFX_MSG_MAP(CMainFrame)
ON_WM_CREATE()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
static UINT indicators[] =
{
ID_SEPARATOR, // status line indicator
ID_INDICATOR_CAPS,
ID_INDICATOR_NUM,
ID_INDICATOR_SCRL,
};
/////////////////////////////////////////////////////////////////////////////
// CMainFrame construction/destruction
CMainFrame::CMainFrame()
{
}
CMainFrame::~CMainFrame()
{
}
int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if (CMDIFrameWnd::OnCreate(lpCreateStruct) == -1)
return -1;
if (!m_wndToolBar.Create(this) ||
!m_wndToolBar.LoadToolBar(IDR_MAINFRAME))
{
TRACE0("Failed to create toolbar\n");
return -1; // fail to create
}
if (!m_wndStatusBar.Create(this) ||
!m_wndStatusBar.SetIndicators(indicators,
sizeof(indicators)/sizeof(UINT)))
{
TRACE0("Failed to create status bar\n");
return -1; // fail to create
}
m_wndToolBar.SetBarStyle(m_wndToolBar.GetBarStyle() |
CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);
m_wndToolBar.EnableDocking(CBRS_ALIGN_ANY);
EnableDocking(CBRS_ALIGN_ANY);
DockControlBar(&m_wndToolBar);
return 0;
}
BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
return CMDIFrameWnd::PreCreateWindow(cs);
}
/////////////////////////////////////////////////////////////////////////////
// CMainFrame diagnostics
#ifdef _DEBUG
void CMainFrame::AssertValid() const
{
CMDIFrameWnd::AssertValid();
}
void CMainFrame::Dump(CDumpContext& dc) const
{
CMDIFrameWnd::Dump(dc);
}
#endif //_DEBUG
/////////////////////////////////////////////////////////////////////////////
// CMainFrame message handlers

72
src/CBot/tests/TestCBot/MainFrm.h
View File

@ -1,72 +0,0 @@
// * This file is part of the COLOBOT source code
// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
// *
// * This program is free software: you can redistribute it and/or modify
// * it under the terms of the GNU General Public License as published by
// * the Free Software Foundation, either version 3 of the License, or
// * (at your option) any later version.
// *
// * This program is distributed in the hope that it will be useful,
// * but WITHOUT ANY WARRANTY; without even the implied warranty of
// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// * GNU General Public License for more details.
// *
// * You should have received a copy of the GNU General Public License
// * along with this program. If not, see http://www.gnu.org/licenses/.
// MainFrm.h : interface of the CMainFrame class
//
/////////////////////////////////////////////////////////////////////////////
#if !defined(AFX_MAINFRM_H__4D1BB907_8E74_11D4_A439_00D059085115__INCLUDED_)
#define AFX_MAINFRM_H__4D1BB907_8E74_11D4_A439_00D059085115__INCLUDED_
#if _MSC_VER >= 1000
#pragma once
#endif // _MSC_VER >= 1000
class CMainFrame : public CMDIFrameWnd
{
DECLARE_DYNAMIC(CMainFrame)
public:
CMainFrame();
// Attributes
public:
// Operations
public:
// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CMainFrame)
public:
virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
//}}AFX_VIRTUAL
// Implementation
public:
virtual ~CMainFrame();
#ifdef _DEBUG
virtual void AssertValid() const;
virtual void Dump(CDumpContext& dc) const;
#endif
protected: // control bar embedded members
CStatusBar m_wndStatusBar;
CToolBar m_wndToolBar;
// Generated message map functions
protected:
//{{AFX_MSG(CMainFrame)
afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
/////////////////////////////////////////////////////////////////////////////
//{{AFX_INSERT_LOCATION}}
// Microsoft Developer Studio will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_MAINFRM_H__4D1BB907_8E74_11D4_A439_00D059085115__INCLUDED_)

177
src/CBot/tests/TestCBot/PerformDlg.cpp
View File

@ -1,177 +0,0 @@
// * This file is part of the COLOBOT source code
// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
// *
// * This program is free software: you can redistribute it and/or modify
// * it under the terms of the GNU General Public License as published by
// * the Free Software Foundation, either version 3 of the License, or
// * (at your option) any later version.
// *
// * This program is distributed in the hope that it will be useful,
// * but WITHOUT ANY WARRANTY; without even the implied warranty of
// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// * GNU General Public License for more details.
// *
// * You should have received a copy of the GNU General Public License
// * along with this program. If not, see http://www.gnu.org/licenses/.
// PerformDlg.cpp : implementation file
//
#include "stdafx.h"
#include "testcbot.h"
#include "PerformDlg.h"
//#include <stdio.h>
#include <sys/timeb.h>
//#include <time.h>
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CPerformDlg dialog
CPerformDlg::CPerformDlg(CWnd* pParent /*=NULL*/)
: CDialog(CPerformDlg::IDD, pParent)
{
//{{AFX_DATA_INIT(CPerformDlg)
// NOTE: the ClassWizard will add member initialization here
//}}AFX_DATA_INIT
}
void CPerformDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CPerformDlg)
DDX_Control(pDX, IDC_EDIT3, m_Edit3);
DDX_Control(pDX, IDC_EDIT1, m_Edit1);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CPerformDlg, CDialog)
//{{AFX_MSG_MAP(CPerformDlg)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CPerformDlg message handlers
/* Pauses for a specified number of milliseconds. */
/*void sleep( double waitseconds )
{
clock_t wait = (clock_t)(waitseconds * CLOCKS_PER_SEC);
clock_t goal;
goal = wait + clock();
while( goal > clock() )
;
}*/
void sleep( clock_t wait )
{
clock_t goal;
goal = wait + clock();
while( goal > clock() )
TRACE("%d \n", clock() );
}
void sleep2( clock_t wait )
{
struct _timeb timebuffer;
char *timeline;
_ftime( &timebuffer );
timeline = ctime( & ( timebuffer.time ) );
long x = timebuffer.millitm;
while( x == timebuffer.millitm ) _ftime( &timebuffer );
}
#define NBLP 20
UINT ThreadProc2(ThreadInfo2 *info)
{
int lp = NBLP;
int i;
clock_t start = clock();
while ( !info->m_bStop )
{
for ( i = 0; i< info->m_nbscripts; i++ )
{
info->m_pProg[i]->Run();
}
#ifdef _DEBUG
sleep2( 1 );
#else
CString s ( "xx" );
for ( long z = 0x5000; z>0; z-- ) s = s.Left(1);
#endif
if ( --lp == 0 )
{
clock_t finish = clock();
double n = (double)NBLP / (double)(finish-start) * CLOCKS_PER_SEC;
char b[30];
sprintf( b, "%f", n);
info->m_pEdit->SetWindowText(b);
n = n * 1100 / 200; // performances
sprintf( b, "%f", n);
info->m_pEdit3->SetWindowText(b);
start = finish;
lp = NBLP;
}
}
return 0 ;
}
BOOL CPerformDlg::OnInitDialog()
{
CDialog::OnInitDialog();
CBotStringArray liste;
// crée les scripts pour les tests
for ( int i = 0; i < 100; i++ )
{
m_pProg[i] = new CBotProgram();
m_pProg[i]->Compile(m_Script, liste);
m_pProg[i]->Start(liste[0]);
}
// lance un processus paralèle pour l'exécution
// m_threadinfo2.m_pWndMessage = this ;
m_threadinfo2.m_pEdit = &m_Edit1;
m_threadinfo2.m_pEdit3 = &m_Edit3;
m_threadinfo2.m_pProg = m_pProg;
m_threadinfo2.m_bStop = FALSE;
m_threadinfo2.m_nbscripts = 30;
AfxBeginThread((AFX_THREADPROC)ThreadProc2, &m_threadinfo2) ;
// TODO: Add extra initialization here
return TRUE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
}
void CPerformDlg::OnCancel()
{
m_threadinfo2.m_bStop = TRUE;
sleep ( 2000 );
CDialog::OnCancel();
for ( int i = 0; i < 100; i++ )
{
delete m_pProg[i];
}
}

78
src/CBot/tests/TestCBot/PerformDlg.h
View File

@ -1,78 +0,0 @@
// * This file is part of the COLOBOT source code
// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
// *
// * This program is free software: you can redistribute it and/or modify
// * it under the terms of the GNU General Public License as published by
// * the Free Software Foundation, either version 3 of the License, or
// * (at your option) any later version.
// *
// * This program is distributed in the hope that it will be useful,
// * but WITHOUT ANY WARRANTY; without even the implied warranty of
// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// * GNU General Public License for more details.
// *
// * You should have received a copy of the GNU General Public License
// * along with this program. If not, see http://www.gnu.org/licenses/.
#if !defined(AFX_PERFORMDLG_H__EAF2D560_97D8_11D4_A439_00D059085115__INCLUDED_)
#define AFX_PERFORMDLG_H__EAF2D560_97D8_11D4_A439_00D059085115__INCLUDED_
#if _MSC_VER >= 1000
#pragma once
#endif // _MSC_VER >= 1000
// PerformDlg.h : header file
//
struct ThreadInfo2
{
CEdit* m_pEdit ;
CEdit* m_pEdit3 ;
CBotProgram** m_pProg;
BOOL m_bStop;
int m_nbscripts;
};
/////////////////////////////////////////////////////////////////////////////
// CPerformDlg dialog
class CPerformDlg : public CDialog
{
// Construction
public:
CPerformDlg(CWnd* pParent = NULL); // standard constructor
// Dialog Data
//{{AFX_DATA(CPerformDlg)
enum { IDD = IDD_DIALOG1 };
CEdit m_Edit3;
CEdit m_Edit1;
//}}AFX_DATA
CBotProgram* m_pProg[100];
ThreadInfo2 m_threadinfo2;
CString m_Script;
// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CPerformDlg)
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
//}}AFX_VIRTUAL
// Implementation
protected:
// Generated message map functions
//{{AFX_MSG(CPerformDlg)
virtual BOOL OnInitDialog();
virtual void OnCancel();
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
//{{AFX_INSERT_LOCATION}}
// Microsoft Developer Studio will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_PERFORMDLG_H__EAF2D560_97D8_11D4_A439_00D059085115__INCLUDED_)

153
src/CBot/tests/TestCBot/Routines.cpp
View File

@ -1,153 +0,0 @@
// * This file is part of the COLOBOT source code
// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
// *
// * This program is free software: you can redistribute it and/or modify
// * it under the terms of the GNU General Public License as published by
// * the Free Software Foundation, either version 3 of the License, or
// * (at your option) any later version.
// *
// * This program is distributed in the hope that it will be useful,
// * but WITHOUT ANY WARRANTY; without even the implied warranty of
// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// * GNU General Public License for more details.
// *
// * You should have received a copy of the GNU General Public License
// * along with this program. If not, see http://www.gnu.org/licenses/.
////////////////////////////////////////////////////////////////////
// routine show()
// utilisable depuis le programme écrit en CBot
// exécution
BOOL rShow( CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser )
{
CString s;
while ( pVar != NULL )
{
CString ss;
ss.LoadString( TX_TYPENAMES + pVar->GivType() );
s += ss + " ";
ss = pVar->GivName();
if (ss.IsEmpty()) ss = "<sans nom>";
s += ss + " = ";
s += pVar->GivValString();
s += "\n";
pVar = pVar->GivNext();
}
AfxMessageBox(s, MB_OK|MB_ICONINFORMATION);
return TRUE; // pas d'interruption
}
CBotTypResult cShow( CBotVar* &pVar, void* pUser)
{
if ( pVar == NULL ) return CBotTypResult(5028);
return CBotTypResult(0); // tous paramètres acceptés, void en retour
}
////////////////////////////////////////////////////////////////////
// routine print()
// utilisable depuis le programme écrit en CBot
// exécution
BOOL rPrintLn( CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser )
{
CString s;
CTestCBotApp* pApp = (CTestCBotApp*)AfxGetApp();
CEdit* pEdit = pApp->m_pConsole;
if (pEdit == NULL) return TRUE;
pEdit->GetWindowText(s);
while ( pVar != NULL )
{
if ( !s.IsEmpty() ) s += " ";
s += pVar->GivValString();
pVar = pVar->GivNext();
}
s += "\r\n";
pEdit->SetWindowText(s);
pEdit->SetSel(s.GetLength(), s.GetLength());
pEdit->SetFocus();
return TRUE; // pas d'interruption
}
BOOL rPrint( CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser )
{
CString s;
CTestCBotApp* pApp = (CTestCBotApp*)AfxGetApp();
CEdit* pEdit = pApp->m_pConsole;
if (pEdit == NULL) return TRUE;
pEdit->GetWindowText(s);
while ( pVar != NULL )
{
if ( !s.IsEmpty() ) s += " ";
s += pVar->GivValString();
pVar = pVar->GivNext();
}
pEdit->SetWindowText(s);
pEdit->SetSel(s.GetLength(), s.GetLength());
pEdit->SetFocus();
return TRUE; // pas d'interruption
}
CBotTypResult cPrint( CBotVar* &pVar, void* pUser)
{
return CBotTypResult(0); // tous paramètres acceptés, un entier en retour
}
//////////////////////////////////////////////////////////////////
// class CPoint pour essayer
// exécution
BOOL rCPoint( CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception )
{
CString s;
if ( pVar == NULL )return TRUE; // constructeur sans paramètres est ok
CBotVar* pX = pThis->GivItem("x");
pX->SetValFloat( pVar->GivValFloat() );
pVar = pVar->GivNext();
CBotVar* pY = pThis->GivItem("y");
pY->SetValFloat( pVar->GivValFloat() );
pVar = pVar->GivNext();
return TRUE; // pas d'interruption
}
CBotTypResult cCPoint( CBotVar* pThis, CBotVar* &pVar)
{
// ok si aucun paramètres !
if ( pVar == NULL ) return CBotTypResult(0);
// paramètre de type numérique svp
if ( pVar->GivType() > CBotTypDouble ) return CBotTypResult(5011);
pVar = pVar->GivNext();
// il doit y avoir un second paramètre
if ( pVar == NULL ) return 5028;
// également de type numérique
if ( pVar->GivType() > CBotTypDouble )return CBotTypResult(5011);
pVar = pVar->GivNext();
// et pas plus de 2 paramètres svp
if ( pVar != NULL ) return CBotTypResult(5026);
return CBotTypResult(0); // cette fonction retourne void
}

40
src/CBot/tests/TestCBot/StdAfx.h
View File

@ -1,40 +0,0 @@
// * This file is part of the COLOBOT source code
// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
// *
// * This program is free software: you can redistribute it and/or modify
// * it under the terms of the GNU General Public License as published by
// * the Free Software Foundation, either version 3 of the License, or
// * (at your option) any later version.
// *
// * This program is distributed in the hope that it will be useful,
// * but WITHOUT ANY WARRANTY; without even the implied warranty of
// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// * GNU General Public License for more details.
// *
// * You should have received a copy of the GNU General Public License
// * along with this program. If not, see http://www.gnu.org/licenses/.// stdafx.h : include file for standard system include files,
// or project specific include files that are used frequently, but
// are changed infrequently
//
#if !defined(AFX_STDAFX_H__4D1BB905_8E74_11D4_A439_00D059085115__INCLUDED_)
#define AFX_STDAFX_H__4D1BB905_8E74_11D4_A439_00D059085115__INCLUDED_
#if _MSC_VER >= 1000
#pragma once
#endif // _MSC_VER >= 1000
#define VC_EXTRALEAN // Exclude rarely-used stuff from Windows headers
#include <afxwin.h> // MFC core and standard components
#include <afxext.h> // MFC extensions
#include <afxdisp.h> // MFC OLE automation classes
#ifndef _AFX_NO_AFXCMN_SUPPORT
#include <afxcmn.h> // MFC support for Windows Common Controls
#endif // _AFX_NO_AFXCMN_SUPPORT
//{{AFX_INSERT_LOCATION}}
// Microsoft Developer Studio will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_STDAFX_H__4D1BB905_8E74_11D4_A439_00D059085115__INCLUDED_)

316
src/CBot/tests/TestCBot/TestCBot.clw
View File

@ -1,316 +0,0 @@
; CLW file contains information for the MFC ClassWizard
[General Info]
Version=1
LastClass=CPerformDlg
LastTemplate=CDialog
NewFileInclude1=#include "stdafx.h"
NewFileInclude2=#include "testcbot.h"
LastPage=0
ClassCount=8
Class1=CBotConsoleDlg
Class2=CChildFrame
Class3=CMainFrame
Class4=CTestCBotApp
Class5=CAboutDlg
Class6=CTestCBotDoc
Class7=CTestCBotView
ResourceCount=12
Resource1=IDD_CONSOLE
Resource2=IDR_TESTCBTYPE (French (France))
Resource3=IDD_ABOUTBOX (French (France))
Resource4=IDR_MAINFRAME (French (France))
Resource5=IDR_MAINFRAME
Resource6=IDR_TESTCBTYPE
Resource7=IDD_ABOUTBOX
Resource8=IDD_CONSOLE (French (Switzerland))
Class8=CPerformDlg
Resource9=IDD_DIALOG1
Resource10=IDD_DIALOG2
Resource11=IDD_DIALOG1 (French (Switzerland))
Resource12=IDD_DIALOG2 (French (France))
[CLS:CBotConsoleDlg]
Type=0
BaseClass=CDialog
HeaderFile=CBotConsoleDlg.h
ImplementationFile=CBotConsoleDlg.cpp
LastObject=IDC_EDIT1
[CLS:CChildFrame]
Type=0
BaseClass=CMDIChildWnd
HeaderFile=ChildFrm.h
ImplementationFile=ChildFrm.cpp
[CLS:CMainFrame]
Type=0
BaseClass=CMDIFrameWnd
HeaderFile=MainFrm.h
ImplementationFile=MainFrm.cpp
Filter=T
VirtualFilter=fWC
LastObject=CMainFrame
[CLS:CTestCBotApp]
Type=0
BaseClass=CWinApp
HeaderFile=TestCBot.h
ImplementationFile=TestCBot.cpp
Filter=N
VirtualFilter=AC
LastObject=ID_TEST
[CLS:CAboutDlg]
Type=0
BaseClass=CDialog
HeaderFile=TestCBot.cpp
ImplementationFile=TestCBot.cpp
LastObject=CAboutDlg
[CLS:CTestCBotDoc]
Type=0
BaseClass=CDocument
HeaderFile=TestCBotDoc.h
ImplementationFile=TestCBotDoc.cpp
LastObject=CTestCBotDoc
Filter=N
VirtualFilter=DC
[CLS:CTestCBotView]
Type=0
BaseClass=CView
HeaderFile=TestCBotView.h
ImplementationFile=TestCBotView.cpp
LastObject=CTestCBotView
Filter=C
VirtualFilter=VWC
[DLG:IDD_CONSOLE]
Type=1
Class=CBotConsoleDlg
ControlCount=4
Control1=IDC_STATIC,static,1342308352
Control2=IDC_EDIT2,edit,1350631552
Control3=IDOK,button,1342242817
Control4=IDC_EDIT1,edit,1352734724
[DLG:IDD_ABOUTBOX]
Type=1
Class=CAboutDlg
ControlCount=7
Control1=IDC_STATIC,static,1342177283
Control2=IDC_STATIC,static,1342308480
Control3=IDC_STATIC,static,1342308352
Control4=IDOK,button,1342373889
Control5=IDC_STATIC,static,1342308352
Control6=IDC_STATIC,static,1342308352
Control7=IDC_STATIC,static,1342308352
[TB:IDR_MAINFRAME (French (France))]
Type=1
Class=?
Command1=ID_FILE_NEW
Command2=ID_FILE_OPEN
Command3=ID_FILE_SAVE
Command4=ID_EDIT_CUT
Command5=ID_EDIT_COPY
Command6=ID_EDIT_PASTE
Command7=ID_FILE_PRINT
Command8=ID_RUN
Command9=ID_APP_ABOUT
CommandCount=9
[MNU:IDR_MAINFRAME (French (France))]
Type=1
Class=?
Command1=ID_FILE_NEW
Command2=ID_FILE_OPEN
Command3=ID_FILE_MRU_FILE1
Command4=ID_APP_EXIT
Command5=ID_VIEW_TOOLBAR
Command6=ID_VIEW_STATUS_BAR
Command7=ID_APP_ABOUT
CommandCount=7
[MNU:IDR_TESTCBTYPE (French (France))]
Type=1
Class=?
Command1=ID_FILE_NEW
Command2=ID_FILE_OPEN
Command3=ID_FILE_CLOSE
Command4=ID_FILE_SAVE
Command5=ID_FILE_SAVE_AS
Command6=ID_FILE_MRU_FILE1
Command7=ID_APP_EXIT
Command8=ID_EDIT_UNDO
Command9=ID_EDIT_CUT
Command10=ID_EDIT_COPY
Command11=ID_EDIT_PASTE
Command12=ID_VIEW_TOOLBAR
Command13=ID_VIEW_STATUS_BAR
Command14=ID_WINDOW_NEW
Command15=ID_WINDOW_CASCADE
Command16=ID_WINDOW_TILE_HORZ
Command17=ID_WINDOW_ARRANGE
Command18=ID_APP_ABOUT
CommandCount=18
[ACL:IDR_MAINFRAME (French (France))]
Type=1
Class=?
Command1=ID_EDIT_COPY
Command2=ID_FILE_NEW
Command3=ID_FILE_OPEN
Command4=ID_FILE_SAVE
Command5=ID_EDIT_PASTE
Command6=ID_EDIT_UNDO
Command7=ID_EDIT_CUT
Command8=ID_RUN
Command9=ID_NEXT_PANE
Command10=ID_PREV_PANE
Command11=ID_RUN
Command12=ID_TEST
Command13=ID_EDIT_COPY
Command14=ID_EDIT_PASTE
Command15=ID_EDIT_CUT
Command16=ID_EDIT_UNDO
CommandCount=16
[DLG:IDD_ABOUTBOX (French (France))]
Type=1
Class=CAboutDlg
ControlCount=7
Control1=IDC_STATIC,static,1342177283
Control2=IDC_STATIC,static,1342308480
Control3=IDC_STATIC,static,1342308352
Control4=IDOK,button,1342373889
Control5=IDC_STATIC,static,1342308352
Control6=IDC_STATIC,static,1342308352
Control7=IDC_STATIC,static,1342308352
[ACL:IDR_MAINFRAME]
Type=1
Command1=ID_EDIT_COPY
Command2=ID_FILE_NEW
Command3=ID_FILE_OPEN
Command4=ID_FILE_SAVE
Command5=ID_EDIT_PASTE
Command6=ID_EDIT_UNDO
Command7=ID_EDIT_CUT
Command8=ID_RUN
Command9=ID_NEXT_PANE
Command10=ID_PREV_PANE
Command11=ID_RUN
Command12=ID_TEST
Command13=ID_EDIT_COPY
Command14=ID_EDIT_PASTE
Command15=ID_EDIT_CUT
Command16=ID_EDIT_UNDO
CommandCount=16
[TB:IDR_MAINFRAME]
Type=1
Command1=ID_FILE_NEW
Command2=ID_FILE_OPEN
Command3=ID_FILE_SAVE
Command4=ID_EDIT_CUT
Command5=ID_EDIT_COPY
Command6=ID_EDIT_PASTE
Command7=ID_FILE_PRINT
Command8=ID_RUN
Command9=ID_APP_ABOUT
CommandCount=9
[MNU:IDR_MAINFRAME]
Type=1
Command1=ID_FILE_NEW
Command2=ID_FILE_OPEN
Command3=ID_FILE_MRU_FILE1
Command4=ID_APP_EXIT
Command5=ID_VIEW_TOOLBAR
Command6=ID_VIEW_STATUS_BAR
Command7=ID_APP_ABOUT
CommandCount=7
[MNU:IDR_TESTCBTYPE]
Type=1
Command1=ID_FILE_NEW
Command2=ID_FILE_OPEN
Command3=ID_FILE_CLOSE
Command4=ID_FILE_SAVE
Command5=ID_FILE_SAVE_AS
Command6=ID_FILE_MRU_FILE1
Command7=ID_APP_EXIT
Command8=ID_EDIT_UNDO
Command9=ID_EDIT_CUT
Command10=ID_EDIT_COPY
Command11=ID_EDIT_PASTE
Command12=ID_VIEW_TOOLBAR
Command13=ID_VIEW_STATUS_BAR
Command14=ID_WINDOW_NEW
Command15=ID_WINDOW_CASCADE
Command16=ID_WINDOW_TILE_HORZ
Command17=ID_WINDOW_ARRANGE
Command18=ID_APP_ABOUT
CommandCount=18
[DLG:IDD_CONSOLE (French (Switzerland))]
Type=1
Class=CBotConsoleDlg
ControlCount=4
Control1=IDC_STATIC,static,1342308352
Control2=IDC_EDIT2,edit,1350631552
Control3=IDOK,button,1342242817
Control4=IDC_EDIT1,edit,1352734724
[DLG:IDD_DIALOG1]
Type=1
Class=CPerformDlg
ControlCount=9
Control1=IDC_STATIC,static,1342308352
Control2=IDC_EDIT1,edit,1350633600
Control3=IDC_STATIC,static,1342308352
Control4=IDC_EDIT2,edit,1350631552
Control5=IDC_SPIN1,msctls_updown32,1342177312
Control6=IDC_COMBO1,combobox,1344339971
Control7=IDC_STATIC,static,1342308352
Control8=IDC_STATIC,static,1342308352
Control9=IDC_EDIT3,edit,1350633600
[CLS:CPerformDlg]
Type=0
HeaderFile=PerformDlg.h
ImplementationFile=PerformDlg.cpp
BaseClass=CDialog
Filter=D
VirtualFilter=dWC
LastObject=IDC_EDIT3
[DLG:IDD_DIALOG2]
Type=1
ControlCount=2
Control1=IDOK,button,1342242817
Control2=IDCANCEL,button,1342242816
[DLG:IDD_DIALOG1 (French (Switzerland))]
Type=1
ControlCount=9
Control1=IDC_STATIC,static,1342308352
Control2=IDC_EDIT1,edit,1350633600
Control3=IDC_STATIC,static,1342308352
Control4=IDC_EDIT2,edit,1350631552
Control5=IDC_SPIN1,msctls_updown32,1342177312
Control6=IDC_COMBO1,combobox,1344339971
Control7=IDC_STATIC,static,1342308352
Control8=IDC_STATIC,static,1342308352
Control9=IDC_EDIT3,edit,1350633600
[DLG:IDD_DIALOG2 (French (France))]
Type=1
ControlCount=2
Control1=IDOK,button,1342242817
Control2=IDCANCEL,button,1342242816

267
src/CBot/tests/TestCBot/TestCBot.cpp
View File

@ -1,267 +0,0 @@
// * This file is part of the COLOBOT source code
// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
// *
// * This program is free software: you can redistribute it and/or modify
// * it under the terms of the GNU General Public License as published by
// * the Free Software Foundation, either version 3 of the License, or
// * (at your option) any later version.
// *
// * This program is distributed in the hope that it will be useful,
// * but WITHOUT ANY WARRANTY; without even the implied warranty of
// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// * GNU General Public License for more details.
// *
// * You should have received a copy of the GNU General Public License
// * along with this program. If not, see http://www.gnu.org/licenses/.// TestCBot.cpp : Defines the class behaviors for the application.
//
#include "stdafx.h"
#include "TestCBot.h"
#include "MainFrm.h"
#include "ChildFrm.h"
#include "TestCBotDoc.h"
#include "TestCBotView.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CTestCBotApp
BEGIN_MESSAGE_MAP(CTestCBotApp, CWinApp)
//{{AFX_MSG_MAP(CTestCBotApp)
ON_COMMAND(ID_APP_ABOUT, OnAppAbout)
//}}AFX_MSG_MAP
// Standard file based document commands
ON_COMMAND(ID_FILE_NEW, CWinApp::OnFileNew)
ON_COMMAND(ID_FILE_OPEN, CWinApp::OnFileOpen)
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CTestCBotApp construction
CTestCBotApp::CTestCBotApp()
{
m_pConsole = NULL;
m_LastActive = NULL;
m_pClassPoint= NULL;
}
/////////////////////////////////////////////////////////////////////////////
// The one and only CTestCBotApp object
CTestCBotApp theApp;
/////////////////////////////////////////////////////////////////////////////
// CTestCBotApp initialization
#include "Routines.cpp"
static char BASED_CODE szSection[] = "Recent File List";
static char BASED_CODE szFilename[] = "File1";
#include "../ClassFILE.cpp"
// routine pour mettre à jour l'instance de la classe Bot courante
void rMajObject( CBotVar* pThis, void* pUser )
{
if (!pThis->IsElemOfClass("object"))
return ;
CBotVar* pPos = pThis->GivItem("position");
CBotVar* pX = pPos->GivItem("x");
CBotVar* pY = pPos->GivItem("y");
CBotVar* pZ = pPos->GivItem("z");
// CBotVar* pPt = pThis->GivItem("transport");
CBotString p = pX->GivValString();
// pX->SetValFloat( pUser == (void*)1 ? (float)12.5 : (float)44.4 );
pZ->SetValFloat( (float)0 );
pY->SetValFloat( (float)-3.33 );
pX->SetValFloat( pX->GivValFloat() + 10 ) ;
// pX = pThis->GivItem( "xx" );
// pX->SetValFloat( (float)22 );
// crée une instance sur une classe object
// CBotVar* pAutre = CBotVar::Create("autre", CBotTypClass, "object");
// pAutre->SetUserPtr( (void*)3 );
// pPt->SetPointer( pAutre );
// pPt->SetPointer( NULL );
// delete pAutre;
}
BOOL CTestCBotApp::InitInstance()
{
//////////////////////////////////////////////
// défini les mots clefs supplémentaires
// -------------------------------------------
CBotProgram::Init();
//////////////////////////////////////////////
// défini les fonctions "show()" et "print()"
// -------------------------------------------
CBotProgram::AddFunction("show", rShow, cShow);
CBotProgram::AddFunction("print", rPrint, cPrint);
CBotProgram::AddFunction("println", rPrintLn, cPrint);
///////////////////////////////////
// définie la classe globale CPoint
// --------------------------------
m_pClassPoint = new CBotClass("CPoint", NULL);
// ajoute le composant ".x"
m_pClassPoint->AddItem("x", CBotTypFloat);
// ajoute le composant ".y"
m_pClassPoint->AddItem("y", CBotTypFloat);
// ajoute le constructeur pour cette classe
m_pClassPoint->AddFunction("CPoint", rCPoint, cCPoint);
m_pClassPointIntr = new CBotClass("point", NULL, TRUE);
// ajoute le composant ".x"
m_pClassPointIntr->AddItem("x", CBotTypFloat);
// ajoute le composant ".y"
m_pClassPointIntr->AddItem("y", CBotTypFloat);
// ajoute le composant ".z"
m_pClassPointIntr->AddItem("z", CBotTypFloat);
// ajoute le constructeur pour cette classe
m_pClassPointIntr->AddFunction("point", rCPoint, cCPoint);
// défini la classe "object"
CBotClass* pClassObject = new CBotClass( "object", NULL ) ;
pClassObject->AddItem( "xx", CBotTypFloat );
pClassObject->AddItem( "position", CBotTypResult( CBotTypIntrinsic, "point" ) );
pClassObject->AddItem( "transport", CBotTypResult( CBotTypPointer, "object" ) );
pClassObject->AddUpdateFunc( rMajObject );
InitClassFILE();
AfxEnableControlContainer();
// Standard initialization
#ifdef _AFXDLL
Enable3dControls(); // Call this when using MFC in a shared DLL
#else
Enable3dControlsStatic(); // Call this when linking to MFC statically
#endif
// Change the registry key under which our settings are stored.
SetRegistryKey(_T("Local AppWizard-Generated Applications"));
LoadStdProfileSettings(); // Load standard INI file options (including MRU)
// Register document templates
CMultiDocTemplate* pDocTemplate;
pDocTemplate = new CMultiDocTemplate(
IDR_TESTCBTYPE,
RUNTIME_CLASS(CTestCBotDoc),
RUNTIME_CLASS(CChildFrame), // custom MDI child frame
RUNTIME_CLASS(CTestCBotView));
AddDocTemplate(pDocTemplate);
// create main MDI Frame window
CMainFrame* pMainFrame = new CMainFrame;
if (!pMainFrame->LoadFrame(IDR_MAINFRAME))
return FALSE;
m_pMainWnd = pMainFrame;
// Parse command line for standard shell commands, DDE, file open
CCommandLineInfo cmdInfo;
ParseCommandLine(cmdInfo);
if (m_lpCmdLine[0] == 0)
{
CString Filename = GetProfileString(szSection, szFilename);
if (Filename.IsEmpty()) Filename = "TstCbot.txt";
else OpenDocumentFile(Filename);
}
else
// Dispatch commands specified on the command line
if (!ProcessShellCommand(cmdInfo))
return FALSE;
pMainFrame->ShowWindow(m_nCmdShow);
pMainFrame->UpdateWindow();
return TRUE;
}
/////////////////////////////////////////////////////////////////////////////
// CAboutDlg dialog used for App About
class CAboutDlg : public CDialog
{
public:
CAboutDlg();
// Dialog Data
//{{AFX_DATA(CAboutDlg)
enum { IDD = IDD_ABOUTBOX };
//}}AFX_DATA
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CAboutDlg)
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
//}}AFX_VIRTUAL
// Implementation
protected:
//{{AFX_MSG(CAboutDlg)
// No message handlers
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
//{{AFX_DATA_INIT(CAboutDlg)
//}}AFX_DATA_INIT
}
void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CAboutDlg)
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
//{{AFX_MSG_MAP(CAboutDlg)
// No message handlers
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
// App command to run the dialog
void CTestCBotApp::OnAppAbout()
{
CAboutDlg aboutDlg;
aboutDlg.DoModal();
}
/////////////////////////////////////////////////////////////////////////////
// CTestCBotApp commands
int CTestCBotApp::ExitInstance()
{
delete m_pFuncFile;
CBotProgram::Free();
return CWinApp::ExitInstance();
}

201
src/CBot/tests/TestCBot/TestCBot.dsp
View File

@ -1,201 +0,0 @@
# Microsoft Developer Studio Project File - Name="TestCBot" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 5.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Application" 0x0101
CFG=TestCBot - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "TestCBot.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "TestCBot.mak" CFG="TestCBot - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "TestCBot - Win32 Release" (based on "Win32 (x86) Application")
!MESSAGE "TestCBot - Win32 Debug" (based on "Win32 (x86) Application")
!MESSAGE
# Begin Project
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
MTL=midl.exe
RSC=rc.exe
!IF "$(CFG)" == "TestCBot - Win32 Release"
# PROP BASE Use_MFC 5
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 5
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "Release"
# PROP Intermediate_Dir "Release"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /Yu"stdafx.h" /FD /c
# ADD CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /FR /Yu"stdafx.h" /FD /c
# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /o NUL /win32
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /o NUL /win32
# ADD BASE RSC /l 0x100c /d "NDEBUG"
# ADD RSC /l 0x100c /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 /nologo /subsystem:windows /machine:I386
# ADD LINK32 /nologo /subsystem:windows /machine:I386
!ELSEIF "$(CFG)" == "TestCBot - Win32 Debug"
# PROP BASE Use_MFC 5
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 5
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "Debug"
# PROP Intermediate_Dir "Debug"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /Yu"stdafx.h" /FD /c
# ADD CPP /nologo /MTd /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /FR /Yu"stdafx.h" /FD /c
# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /o NUL /win32
# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /o NUL /win32
# ADD BASE RSC /l 0x100c /d "_DEBUG"
# ADD RSC /l 0x100c /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept
# ADD LINK32 /nologo /stack:0x7010 /subsystem:windows /debug /machine:I386 /pdbtype:sept
!ENDIF
# Begin Target
# Name "TestCBot - Win32 Release"
# Name "TestCBot - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=.\CBotConsoleDlg.cpp
# End Source File
# Begin Source File
SOURCE=.\ChildFrm.cpp
# End Source File
# Begin Source File
SOURCE=.\MainFrm.cpp
# End Source File
# Begin Source File
SOURCE=.\PerformDlg.cpp
# End Source File
# Begin Source File
SOURCE=.\StdAfx.cpp
# ADD CPP /Yc"stdafx.h"
# End Source File
# Begin Source File
SOURCE=.\TestCBot.cpp
# End Source File
# Begin Source File
SOURCE=.\TestCBot.rc
!IF "$(CFG)" == "TestCBot - Win32 Release"
!ELSEIF "$(CFG)" == "TestCBot - Win32 Debug"
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\TestCBotDoc.cpp
# End Source File
# Begin Source File
SOURCE=.\TestCBotView.cpp
# End Source File
# End Group
# Begin Group "Header Files"
# PROP Default_Filter "h;hpp;hxx;hm;inl"
# Begin Source File
SOURCE=.\CBotConsoleDlg.h
# End Source File
# Begin Source File
SOURCE=.\ChildFrm.h
# End Source File
# Begin Source File
SOURCE=.\MainFrm.h
# End Source File
# Begin Source File
SOURCE=.\PerformDlg.h
# End Source File
# Begin Source File
SOURCE=.\Resource.h
# End Source File
# Begin Source File
SOURCE=.\StdAfx.h
# End Source File
# Begin Source File
SOURCE=.\TestCBot.h
# End Source File
# Begin Source File
SOURCE=.\TestCBotDoc.h
# End Source File
# Begin Source File
SOURCE=.\TestCBotView.h
# End Source File
# End Group
# Begin Group "Resource Files"
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;cnt;rtf;gif;jpg;jpeg;jpe"
# Begin Source File
SOURCE=.\res\TestCBot.ico
# End Source File
# Begin Source File
SOURCE=.\res\TestCBot.rc2
# End Source File
# Begin Source File
SOURCE=.\res\TestCBotDoc.ico
# End Source File
# Begin Source File
SOURCE=.\res\Toolbar.bmp
# End Source File
# End Group
# Begin Source File
SOURCE=..\Debug\CBot.lib
# End Source File
# End Target
# End Project

78
src/CBot/tests/TestCBot/TestCBot.h
View File

@ -1,78 +0,0 @@
// * This file is part of the COLOBOT source code
// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
// *
// * This program is free software: you can redistribute it and/or modify
// * it under the terms of the GNU General Public License as published by
// * the Free Software Foundation, either version 3 of the License, or
// * (at your option) any later version.
// *
// * This program is distributed in the hope that it will be useful,
// * but WITHOUT ANY WARRANTY; without even the implied warranty of
// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// * GNU General Public License for more details.
// *
// * You should have received a copy of the GNU General Public License
// * along with this program. If not, see http://www.gnu.org/licenses/.// TestCBot.h : main header file for the TESTCBOT application
//
#if !defined(AFX_TESTCBOT_H__4D1BB903_8E74_11D4_A439_00D059085115__INCLUDED_)
#define AFX_TESTCBOT_H__4D1BB903_8E74_11D4_A439_00D059085115__INCLUDED_
#if _MSC_VER >= 1000
#pragma once
#endif // _MSC_VER >= 1000
#ifndef __AFXWIN_H__
#error include 'stdafx.h' before including this file for PCH
#endif
#include "resource.h" // main symbols
//#include "../CbotDll.h" // librairie CBot
#include "../Cbot.h" // complet pour Browse
class CTestCBotView;
/////////////////////////////////////////////////////////////////////////////
// CTestCBotApp:
// See TestCBot.cpp for the implementation of this class
//
class CTestCBotApp : public CWinApp
{
public:
CTestCBotApp();
CEdit* m_pConsole;
CTestCBotView* m_LastActive;
CBotClass* m_pClassPoint;
CBotClass* m_pClassPointIntr;
// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CTestCBotApp)
public:
virtual BOOL InitInstance();
virtual int ExitInstance();
//}}AFX_VIRTUAL
// Implementation
//{{AFX_MSG(CTestCBotApp)
afx_msg void OnAppAbout();
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
/////////////////////////////////////////////////////////////////////////////
//{{AFX_INSERT_LOCATION}}
// Microsoft Developer Studio will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_TESTCBOT_H__4D1BB903_8E74_11D4_A439_00D059085115__INCLUDED_)
#define WM_STARTPROG WM_APP + 0
#define WM_ENDPROG WM_APP + 1
#define WM_ACTWINDOW WM_APP + 2

564
src/CBot/tests/TestCBot/TestCBot.rc
View File

@ -1,564 +0,0 @@
//Microsoft Developer Studio generated resource script.
//
#include "resource.h"
#define APSTUDIO_READONLY_SYMBOLS
/////////////////////////////////////////////////////////////////////////////
//
// Generated from the TEXTINCLUDE 2 resource.
//
#include "afxres.h"
/////////////////////////////////////////////////////////////////////////////
#undef APSTUDIO_READONLY_SYMBOLS
/////////////////////////////////////////////////////////////////////////////
// French (France) resources
#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_FRA)
#ifdef _WIN32
LANGUAGE LANG_FRENCH, SUBLANG_FRENCH
#pragma code_page(1252)
#endif //_WIN32
/////////////////////////////////////////////////////////////////////////////
//
// Icon
//
// Icon with lowest ID value placed first to ensure application icon
// remains consistent on all systems.
IDR_MAINFRAME ICON DISCARDABLE "res\\TestCBot.ico"
IDR_TESTCBTYPE ICON DISCARDABLE "res\\TestCBotDoc.ico"
/////////////////////////////////////////////////////////////////////////////
//
// Bitmap
//
IDR_MAINFRAME BITMAP MOVEABLE PURE "res\\Toolbar.bmp"
/////////////////////////////////////////////////////////////////////////////
//
// Toolbar
//
IDR_MAINFRAME TOOLBAR DISCARDABLE 16, 15
BEGIN
BUTTON ID_FILE_NEW
BUTTON ID_FILE_OPEN
BUTTON ID_FILE_SAVE
SEPARATOR
BUTTON ID_EDIT_CUT
BUTTON ID_EDIT_COPY
BUTTON ID_EDIT_PASTE
SEPARATOR
BUTTON ID_FILE_PRINT
BUTTON ID_RUN
SEPARATOR
BUTTON ID_APP_ABOUT
END
/////////////////////////////////////////////////////////////////////////////
//
// Menu
//
IDR_MAINFRAME MENU PRELOAD DISCARDABLE
BEGIN
POPUP "&Fichier"
BEGIN
MENUITEM "&Nouveau\tCtrl+N", ID_FILE_NEW
MENUITEM "&Ouvrir...\tCtrl+O", ID_FILE_OPEN
MENUITEM SEPARATOR
MENUITEM "Fichier récent", ID_FILE_MRU_FILE1, GRAYED
MENUITEM SEPARATOR
MENUITEM "&Quitter", ID_APP_EXIT
END
POPUP "&Affichage"
BEGIN
MENUITEM "&Barre d'outils", ID_VIEW_TOOLBAR
MENUITEM "Barre d'é&tat", ID_VIEW_STATUS_BAR
END
POPUP "&?"
BEGIN
MENUITEM "&A propos de TestCBot...", ID_APP_ABOUT
END
END
IDR_TESTCBTYPE MENU PRELOAD DISCARDABLE
BEGIN
POPUP "&Fichier"
BEGIN
MENUITEM "&Nouveau\tCtrl+N", ID_FILE_NEW
MENUITEM "&Ouvrir...\tCtrl+O", ID_FILE_OPEN
MENUITEM "&Fermer", ID_FILE_CLOSE
MENUITEM "&Enregistrer\tCtrl+S", ID_FILE_SAVE
MENUITEM "En&registrer sous...", ID_FILE_SAVE_AS
MENUITEM SEPARATOR
MENUITEM "Fichier récent", ID_FILE_MRU_FILE1, GRAYED
MENUITEM SEPARATOR
MENUITEM "&Quitter", ID_APP_EXIT
END
POPUP "&Edition"
BEGIN
MENUITEM "&Annuler\tCtrl+Z", ID_EDIT_UNDO
MENUITEM SEPARATOR
MENUITEM "&Couper\tCtrl+X", ID_EDIT_CUT
MENUITEM "&Copier\tCtrl+C", ID_EDIT_COPY
MENUITEM "C&oller\tCtrl+V", ID_EDIT_PASTE
END
POPUP "&Affichage"
BEGIN
MENUITEM "&Barre d'outils", ID_VIEW_TOOLBAR
MENUITEM "Barre d'é&tat", ID_VIEW_STATUS_BAR
END
POPUP "Fe&nêtre"
BEGIN
MENUITEM "&Nouvelle fenêtre", ID_WINDOW_NEW
MENUITEM "&Cascade", ID_WINDOW_CASCADE
MENUITEM "&Mosaïque", ID_WINDOW_TILE_HORZ
MENUITEM "&Réorganiser les icônes", ID_WINDOW_ARRANGE
END
POPUP "&?"
BEGIN
MENUITEM "&A propos de TestCBot...", ID_APP_ABOUT
END
END
/////////////////////////////////////////////////////////////////////////////
//
// Accelerator
//
IDR_MAINFRAME ACCELERATORS PRELOAD MOVEABLE PURE
BEGIN
"C", ID_EDIT_COPY, VIRTKEY, CONTROL, NOINVERT
"N", ID_FILE_NEW, VIRTKEY, CONTROL, NOINVERT
"O", ID_FILE_OPEN, VIRTKEY, CONTROL, NOINVERT
"S", ID_FILE_SAVE, VIRTKEY, CONTROL, NOINVERT
"V", ID_EDIT_PASTE, VIRTKEY, CONTROL, NOINVERT
VK_BACK, ID_EDIT_UNDO, VIRTKEY, ALT, NOINVERT
VK_DELETE, ID_EDIT_CUT, VIRTKEY, SHIFT, NOINVERT
VK_F5, ID_RUN, VIRTKEY, NOINVERT
VK_F6, ID_NEXT_PANE, VIRTKEY, NOINVERT
VK_F6, ID_PREV_PANE, VIRTKEY, SHIFT, NOINVERT
VK_F7, ID_RUN, VIRTKEY, NOINVERT
VK_F9, ID_TEST, VIRTKEY, NOINVERT
VK_INSERT, ID_EDIT_COPY, VIRTKEY, CONTROL, NOINVERT
VK_INSERT, ID_EDIT_PASTE, VIRTKEY, SHIFT, NOINVERT
"X", ID_EDIT_CUT, VIRTKEY, CONTROL, NOINVERT
"Z", ID_EDIT_UNDO, VIRTKEY, CONTROL, NOINVERT
END
/////////////////////////////////////////////////////////////////////////////
//
// Dialog
//
IDD_ABOUTBOX DIALOG DISCARDABLE 0, 0, 265, 206
STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
CAPTION "A propos de TestCBot"
FONT 8, "MS Sans Serif"
BEGIN
ICON IDR_MAINFRAME,IDC_STATIC,11,17,21,20
LTEXT "TestCBot version 1.0",IDC_STATIC,40,10,119,8,
SS_NOPREFIX
LTEXT "Copyright D. Dumoulin (C) 2000",IDC_STATIC,40,25,119,8
DEFPUSHBUTTON "OK",IDOK,226,7,32,14,WS_GROUP
LTEXT "Programme de test pour la librairie CBot\n\nLes fonctions doivent être déclarées comme ""extern"" pour apparaître dans la liste lors de l'exécution.\n\n",
IDC_STATIC,39,43,191,41
LTEXT "Mais en fait, on peut accèder à toutes les fonctions marquées ""public"" quelles soient dans la fenêtre active ou non.",
IDC_STATIC,39,89,187,36
LTEXT "Les fonctions print( ... ) et println( ...) permettent d'afficher des résultats dans la console.\n\nLa fonction show( ... ) affiche les paramètres dans un dialogue, et suspend donc l'exécution.",
IDC_STATIC,39,130,187,54
END
IDD_DIALOG2 DIALOG DISCARDABLE 0, 0, 186, 95
STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
CAPTION "Dialog"
FONT 8, "MS Sans Serif"
BEGIN
DEFPUSHBUTTON "OK",IDOK,129,7,50,14
PUSHBUTTON "Cancel",IDCANCEL,129,24,50,14
END
#ifndef _MAC
/////////////////////////////////////////////////////////////////////////////
//
// Version
//
VS_VERSION_INFO VERSIONINFO
FILEVERSION 1,0,0,1
PRODUCTVERSION 1,0,0,1
FILEFLAGSMASK 0x3fL
#ifdef _DEBUG
FILEFLAGS 0x1L
#else
FILEFLAGS 0x0L
#endif
FILEOS 0x4L
FILETYPE 0x1L
FILESUBTYPE 0x0L
BEGIN
BLOCK "StringFileInfo"
BEGIN
BLOCK "040C04B0"
BEGIN
VALUE "CompanyName", "\0"
VALUE "FileDescription", "Application MFC TestCBot\0"
VALUE "FileVersion", "1, 0, 0, 1\0"
VALUE "InternalName", "TestCBot\0"
VALUE "LegalCopyright", "Copyright (C) 1900\0"
VALUE "LegalTrademarks", "\0"
VALUE "OriginalFilename", "TestCBot.EXE\0"
VALUE "ProductName", "Application TestCBot\0"
VALUE "ProductVersion", "1, 0, 0, 1\0"
END
END
BLOCK "VarFileInfo"
BEGIN
VALUE "Traduction", 0x40c, 1200
END
END
#endif // !_MAC
/////////////////////////////////////////////////////////////////////////////
//
// DESIGNINFO
//
#ifdef APSTUDIO_INVOKED
GUIDELINES DESIGNINFO DISCARDABLE
BEGIN
IDD_ABOUTBOX, DIALOG
BEGIN
LEFTMARGIN, 7
RIGHTMARGIN, 258
TOPMARGIN, 7
BOTTOMMARGIN, 199
END
IDD_DIALOG2, DIALOG
BEGIN
LEFTMARGIN, 7
RIGHTMARGIN, 179
TOPMARGIN, 7
BOTTOMMARGIN, 88
END
END
#endif // APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
//
// String Table
//
STRINGTABLE PRELOAD DISCARDABLE
BEGIN
IDR_MAINFRAME "TestCBot"
IDR_TESTCBTYPE "\nTestCBot\nTestCBot\nCBot (*.txt)\n.txt\nTestCBot.Document\nTestCB Document"
END
STRINGTABLE PRELOAD DISCARDABLE
BEGIN
AFX_IDS_APP_TITLE "TestCBot"
AFX_IDS_IDLEMESSAGE "Prêt"
END
STRINGTABLE DISCARDABLE
BEGIN
ID_INDICATOR_EXT "EXT"
ID_INDICATOR_CAPS "MAJ"
ID_INDICATOR_NUM "NUM"
ID_INDICATOR_SCRL "DEF"
ID_INDICATOR_OVR "ECR"
ID_INDICATOR_REC "ENR"
END
STRINGTABLE DISCARDABLE
BEGIN
ID_FILE_NEW "Crée un nouveau document\nNouveau"
ID_FILE_OPEN "Ouvre un document existant\nOuvrir"
ID_FILE_CLOSE "Ferme le document actif\nFermer"
ID_FILE_SAVE "Enregistre le document actif\nEnregistrer"
ID_FILE_SAVE_AS "Enregistre le document actif sous un nouveau nom\nEnregistrer sous"
ID_FILE_PRINT "Imprime le document\nImprime"
END
STRINGTABLE DISCARDABLE
BEGIN
ID_APP_ABOUT "Affiche des informations sur le programme\nA propos de"
ID_APP_EXIT "Ferme l'application ; propose d'enregistrer les documents\nQuitter"
END
STRINGTABLE DISCARDABLE
BEGIN
ID_FILE_MRU_FILE1 "Ouvre ce document"
ID_FILE_MRU_FILE2 "Ouvre ce document"
ID_FILE_MRU_FILE3 "Ouvre ce document"
ID_FILE_MRU_FILE4 "Ouvre ce document"
ID_FILE_MRU_FILE5 "Ouvre ce document"
ID_FILE_MRU_FILE6 "Ouvre ce document"
ID_FILE_MRU_FILE7 "Ouvre ce document"
ID_FILE_MRU_FILE8 "Ouvre ce document"
ID_FILE_MRU_FILE9 "Ouvre ce document"
ID_FILE_MRU_FILE10 "Ouvre ce document"
ID_FILE_MRU_FILE11 "Ouvre ce document"
ID_FILE_MRU_FILE12 "Ouvre ce document"
ID_FILE_MRU_FILE13 "Ouvre ce document"
ID_FILE_MRU_FILE14 "Ouvre ce document"
ID_FILE_MRU_FILE15 "Ouvre ce document"
ID_FILE_MRU_FILE16 "Ouvre ce document"
END
STRINGTABLE DISCARDABLE
BEGIN
ID_NEXT_PANE "Passe au volet de fenêtre suivant\nVolet suivant"
ID_PREV_PANE "Revient au volet précédent\nVolet précédent"
END
STRINGTABLE DISCARDABLE
BEGIN
ID_WINDOW_NEW "Ouvre une nouvelle fenêtre pour le document actif\nNouvelle fenêtre"
ID_WINDOW_ARRANGE "Réorganise les icônes en bas de la fenêtre\nRéorganise les icônes"
ID_WINDOW_CASCADE "Réorganise les fenêtres en cascade\nCascade"
ID_WINDOW_TILE_HORZ "Réorganise les fenêtres en une mosaïque\nMosaïque"
ID_WINDOW_TILE_VERT "Réorganise les fenêtres en une mosaïque\nMosaïque"
ID_WINDOW_SPLIT "Fractionne la fenêtre active en deux volets\nFractionner"
END
STRINGTABLE DISCARDABLE
BEGIN
ID_EDIT_CLEAR "Efface la sélection\nEffacer"
ID_EDIT_CLEAR_ALL "Efface tout\nEffacer tout"
ID_EDIT_COPY "Copie la sélection et la place dans le Presse-papiers\nCopier"
ID_EDIT_CUT "Supprime la sélection et la place dans le Presse-papiers\nCopier"
ID_EDIT_FIND "Recherche le texte spécifié\nRechercher"
ID_EDIT_PASTE "Insère le contenu du Presse-papiers\nColler"
ID_EDIT_REPEAT "Répète la dernière action\nRépéter"
ID_EDIT_REPLACE "Remplace le texte spécifique par un texte différent\nRemplacer"
ID_EDIT_SELECT_ALL "Sélectionne le document entier\nSélectionner tout"
ID_EDIT_UNDO "Annule la dernière action\nAnnuler"
ID_EDIT_REDO "Rétablit l'action précédemment annulée\nRétablir"
END
STRINGTABLE DISCARDABLE
BEGIN
ID_VIEW_TOOLBAR "Affiche ou masque la barre d'outils\nBarre d'outils"
ID_VIEW_STATUS_BAR "Affiche ou masque la barre d'état\nBarre d'état"
END
STRINGTABLE DISCARDABLE
BEGIN
AFX_IDS_SCSIZE "Change la taille de la fenêtre"
AFX_IDS_SCMOVE "Change la position de la fenêtre"
AFX_IDS_SCMINIMIZE "Réduit la fenêtre en icône"
AFX_IDS_SCMAXIMIZE "Agrandit la fenêtre au format de l'écran"
AFX_IDS_SCNEXTWINDOW "Passe à la fenêtre de document suivante"
AFX_IDS_SCPREVWINDOW "Passe à la fenêtre de document précédente"
AFX_IDS_SCCLOSE "Ferme la fenêtre active et propose l'enregistrement des documents"
END
STRINGTABLE DISCARDABLE
BEGIN
AFX_IDS_SCRESTORE "Restaure la fenêtre à sa taille d'origine"
AFX_IDS_SCTASKLIST "Active la liste des tâches"
AFX_IDS_MDICHILD "Active cette fenêtre"
END
STRINGTABLE DISCARDABLE
BEGIN
ID_RUN "Execute le programme CBot\nExecute (F5)"
END
STRINGTABLE DISCARDABLE
BEGIN
TX_TYPENAMES "les différents types"
1001 "Byte"
1002 "Short"
1003 "Char"
1004 "Int"
1005 "Long"
1006 "Real"
1007 "Double"
END
STRINGTABLE DISCARDABLE
BEGIN
1008 "Boolean"
1009 "String"
1010 "Array"
1011 "Arraybody"
1012 "Pointer"
1013 "Nullpointer"
1014 "nop"
1015 "Class"
1016 "Intrinsic"
END
#endif // French (France) resources
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// French (Switzerland) resources
#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_FRS)
#ifdef _WIN32
LANGUAGE LANG_FRENCH, SUBLANG_FRENCH_SWISS
#pragma code_page(1252)
#endif //_WIN32
/////////////////////////////////////////////////////////////////////////////
//
// Dialog
//
IDD_CONSOLE DIALOG DISCARDABLE 0, 0, 401, 210
STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
CAPTION "CBot Console"
FONT 8, "MS Sans Serif"
BEGIN
LTEXT "Commande :",IDC_STATIC,7,177,40,8
EDITTEXT IDC_EDIT2,7,189,329,14,ES_AUTOHSCROLL
DEFPUSHBUTTON "Exécute",IDOK,344,189,50,14
EDITTEXT IDC_EDIT1,7,7,387,167,ES_MULTILINE | ES_READONLY |
ES_WANTRETURN | WS_VSCROLL
END
IDD_DIALOG1 DIALOG DISCARDABLE 0, 0, 177, 100
STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
CAPTION "Test performances"
FONT 8, "MS Sans Serif"
BEGIN
LTEXT "Boucles par seconde",IDC_STATIC,7,9,68,8
EDITTEXT IDC_EDIT1,111,7,51,14,ES_AUTOHSCROLL | ES_READONLY
LTEXT "Nombre de scripts",IDC_STATIC,7,55,58,8
EDITTEXT IDC_EDIT2,111,52,40,14,ES_AUTOHSCROLL
CONTROL "Spin1",IDC_SPIN1,"msctls_updown32",UDS_ARROWKEYS,152,52,
10,14
COMBOBOX IDC_COMBO1,111,74,52,111,CBS_DROPDOWNLIST | WS_VSCROLL |
WS_TABSTOP
LTEXT "Timer",IDC_STATIC,7,77,18,8
LTEXT "Performance %",IDC_STATIC,7,28,48,8
EDITTEXT IDC_EDIT3,111,25,51,14,ES_AUTOHSCROLL | ES_READONLY
END
/////////////////////////////////////////////////////////////////////////////
//
// DESIGNINFO
//
#ifdef APSTUDIO_INVOKED
GUIDELINES DESIGNINFO DISCARDABLE
BEGIN
IDD_CONSOLE, DIALOG
BEGIN
LEFTMARGIN, 7
RIGHTMARGIN, 394
TOPMARGIN, 7
BOTTOMMARGIN, 203
END
IDD_DIALOG1, DIALOG
BEGIN
LEFTMARGIN, 7
RIGHTMARGIN, 170
TOPMARGIN, 7
BOTTOMMARGIN, 93
END
END
#endif // APSTUDIO_INVOKED
#ifdef APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
//
// TEXTINCLUDE
//
1 TEXTINCLUDE DISCARDABLE
BEGIN
"resource.h\0"
END
2 TEXTINCLUDE DISCARDABLE
BEGIN
"#include ""afxres.h""\r\n"
"\0"
END
3 TEXTINCLUDE DISCARDABLE
BEGIN
"#define _AFX_NO_SPLITTER_RESOURCES\r\n"
"#define _AFX_NO_OLE_RESOURCES\r\n"
"#define _AFX_NO_TRACKER_RESOURCES\r\n"
"#define _AFX_NO_PROPERTY_RESOURCES\r\n"
"\r\n"
"#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_FRA)\r\n"
"#ifdef _WIN32\r\n"
"LANGUAGE 12, 1\r\n"
"#pragma code_page(1252)\r\n"
"#endif\r\n"
"#include ""res\\TestCBot.rc2"" // non-Microsoft Visual C++ edited resources\r\n"
"#include ""l.fra\\afxres.rc"" // Standard components\r\n"
"#endif\0"
END
#endif // APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
//
// Dialog Info
//
IDD_DIALOG1 DLGINIT
BEGIN
IDC_COMBO1, 0x403, 2, 0
0x0031,
IDC_COMBO1, 0x403, 3, 0
0x3031, "\000"
IDC_COMBO1, 0x403, 4, 0
0x3031, 0x0030,
IDC_COMBO1, 0x403, 5, 0
0x3031, 0x3030, "\000"
0
END
#endif // French (Switzerland) resources
/////////////////////////////////////////////////////////////////////////////
#ifndef APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
//
// Generated from the TEXTINCLUDE 3 resource.
//
#define _AFX_NO_SPLITTER_RESOURCES
#define _AFX_NO_OLE_RESOURCES
#define _AFX_NO_TRACKER_RESOURCES
#define _AFX_NO_PROPERTY_RESOURCES
#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_FRA)
#ifdef _WIN32
LANGUAGE 12, 1
#pragma code_page(1252)
#endif
#include "res\TestCBot.rc2" // non-Microsoft Visual C++ edited resources
#include "l.fra\afxres.rc" // Standard components
#endif
/////////////////////////////////////////////////////////////////////////////
#endif // not APSTUDIO_INVOKED

697
src/CBot/tests/TestCBot/TestCBotDoc.cpp
View File

@ -1,697 +0,0 @@
// * This file is part of the COLOBOT source code
// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
// *
// * This program is free software: you can redistribute it and/or modify
// * it under the terms of the GNU General Public License as published by
// * the Free Software Foundation, either version 3 of the License, or
// * (at your option) any later version.
// *
// * This program is distributed in the hope that it will be useful,
// * but WITHOUT ANY WARRANTY; without even the implied warranty of
// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// * GNU General Public License for more details.
// *
// * You should have received a copy of the GNU General Public License
// * along with this program. If not, see http://www.gnu.org/licenses/.// TestCBotDoc.cpp : implementation of the CTestCBotDoc class
//
#include "stdafx.h"
#include "TestCBot.h"
#include "TestCBotDoc.h"
#include "TestCBotView.h"
#include "CBotConsoleDlg.h"
#include "PerformDlg.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CTestCBotDoc
IMPLEMENT_DYNCREATE(CTestCBotDoc, CDocument)
BEGIN_MESSAGE_MAP(CTestCBotDoc, CDocument)
//{{AFX_MSG_MAP(CTestCBotDoc)
ON_COMMAND(ID_RUN, OnRun)
ON_EN_CHANGE(IDC_EDIT1, OnChangeEdit1)
ON_COMMAND(ID_TEST, OnTest)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CTestCBotDoc construction/destruction
static BOOL test = FALSE;
CTestCBotDoc::CTestCBotDoc()
{
m_pEdit = NULL;
m_pProg = NULL;
m_bModified = FALSE;
}
CTestCBotDoc::~CTestCBotDoc()
{
delete m_pEdit;
delete m_pProg;
}
BOOL CTestCBotDoc::OnNewDocument()
{
if (!CDocument::OnNewDocument())
return FALSE;
return TRUE;
}
/////////////////////////////////////////////////////////////////////////////
// CTestCBotDoc serialization
void CTestCBotDoc::Serialize(CArchive& ar)
{
if (ar.IsStoring())
{
m_pEdit->GetWindowText(m_DocText);
int w = m_DocText.GetLength();
ar.Write((LPCTSTR)m_DocText, w);
}
else
{
int r;
char buf[10001];
r = ar.Read(buf, 10000);
buf[r] = 0;
m_DocText = buf;
if ( m_pProg == NULL ) m_pProg = new CBotProgram();
if (!m_pProg->Compile(m_DocText, m_Liste, NULL))
{
delete m_pProg;
m_pProg = NULL;
}
}
}
/////////////////////////////////////////////////////////////////////////////
// CTestCBotDoc diagnostics
#ifdef _DEBUG
void CTestCBotDoc::AssertValid() const
{
CDocument::AssertValid();
}
void CTestCBotDoc::Dump(CDumpContext& dc) const
{
CDocument::Dump(dc);
}
#endif //_DEBUG
/////////////////////////////////////////////////////////////////////////////
// CTestCBotDoc commands
void CTestCBotDoc::OnRun()
{
OnFileSave();
m_pEdit->GetWindowText(m_DocText);
CString TextError;
int code, start, end;
if ( m_pProg == NULL ) m_pProg = new CBotProgram();
CTestCBotApp* pApp = (CTestCBotApp*)AfxGetApp();
if (!m_pProg->Compile(m_DocText, m_Liste, NULL))
{
m_pProg->GetError(code, start, end);
delete m_pProg;
m_pProg = NULL;
m_pEdit->SetSel( start, end );
m_pEdit->SetFocus(); // met en évidence la partie avec problème
TextError = CBotProgram::GivErrorText( code );
AfxMessageBox( TextError );
m_pEdit->SetFocus();
return;
}
if( m_Liste.GivSize() == 0 )
{
AfxMessageBox("Aucune fonction marquée \"extern\" !");
return;
}
for ( int i = 0; i < m_Liste.GivSize(); i++ )
{
int start, stop;
m_pProg->GetPosition(m_Liste[i], start, stop, GetPosNom, GetPosParam);
m_Liste[i] = m_DocText.Mid( start, stop-start );
}
CBotConsoleDlg dlg;
dlg.m_pListe = &m_Liste;
dlg.m_pEditx = m_pEdit;
dlg.DoModal(); // dialogue pour faire la console
if ( dlg.m_code>0 )
{
CString TextError;
TextError = m_pProg->GivErrorText( dlg.m_code );
m_pEdit->SetSel( dlg.m_start, dlg.m_end );
m_pEdit->SetFocus(); // met en évidence la partie avec problème
AfxMessageBox(TextError);
}
m_pEdit->SetFocus();
return;
}
void CTestCBotDoc::OnChangeEdit1()
{
SetModifiedFlag();
m_bModified = TRUE;
}
BOOL CTestCBotDoc::Compile()
{
m_pEdit->GetWindowText(m_DocText);
CString TextError;
int code, start, end;
if ( m_pProg == NULL ) m_pProg = new CBotProgram();
char buffer[100];
strcpy(buffer, "le pointeur à passer pour voir");
if (m_bModified && !m_pProg->Compile(m_DocText, m_Liste, (void*)buffer))
{
m_pProg->GetError(code, start, end);
delete m_pProg;
m_pProg = NULL;
m_pEdit->SetSel( start, end );
m_pEdit->SetFocus(); // met en évidence la partie avec problème
TextError = CBotProgram::GivErrorText( code );
AfxMessageBox( TextError );
m_pEdit->SetFocus();
m_bModified = FALSE;
return FALSE;
}
if ( m_pProg->GetPosition( "TheTest", start, end) )
{
m_pEdit->SetSel( start, end );
m_pEdit->SetFocus(); // met en évidence la partie avec problème
}
m_bModified = FALSE;
return TRUE;
}
static int compt = 0;
// routine retournant le "pointeur" à un autre object
BOOL rRetObject( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
{
pResult->SetPointer( NULL );
compt+=45671;
if (compt&0x11) return TRUE;
CBotVar* pAutre = CBotVar::Create("autre", CBotTypResult( CBotTypClass, "object" ));
pAutre->SetUserPtr( (void*)2 );
pResult->SetPointer( pAutre );
if (!pResult->IsElemOfClass("object"))
return TRUE;
delete pAutre;
return TRUE;
}
CBotTypResult cRetObject( CBotVar* &pVar, void* pUser )
{
return CBotTypResult( CBotTypPointer, "object");
}
BOOL roRadar( CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception )
{
pResult->SetPointer( NULL );
compt+=45671;
if (compt&0x11) return TRUE;
CBotVar* pAutre = CBotVar::Create("autre", CBotTypResult( CBotTypClass, "object" ));
pAutre->SetUserPtr( (void*)2 );
pResult->SetPointer( pAutre );
if (!pResult->IsElemOfClass("object"))
return TRUE;
delete pAutre;
return TRUE;
}
CBotTypResult coRadar( CBotVar* pThis, CBotVar* &pVar )
{
void* pUser = pThis->GivUserPtr();
return CBotTypResult( CBotTypPointer, "object");
}
BOOL rMove( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
{
if ( test < 12 )
{
test++;
return FALSE;
}
return TRUE;
}
CBotTypResult cMove( CBotVar* &pVar, void* pUser )
{
return CBotTypResult( 0 );
}
BOOL rTurn( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
{
return TRUE;
}
CBotTypResult cTurn( CBotVar* &pVar, void* pUser )
{
return CBotTypResult( 0 );
}
BOOL rRadar( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
{
pResult->SetPointer( NULL );
if ( pVar ) pVar->debug();
compt+=45671;
if (compt&0x11)
{
return FALSE; // TRUE;
}
CBotVar* pAutre = CBotVar::Create("autre", CBotTypResult( CBotTypClass, "object" ));
pAutre->SetUserPtr( (void*)2 );
pResult->SetPointer( pAutre );
if (!pResult->IsElemOfClass("object"))
return TRUE;
delete pAutre;
return TRUE;
}
CBotTypResult cRadar( CBotVar* &pVar, void* pUser )
{
return CBotTypResult( CBotTypPointer, "object");
}
// routine retournant le "pointeur" à un autre object
BOOL rTEST( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
{
test = 1 ;
if ( pVar == NULL ) return TRUE;
test = pVar->GivValInt();
if ( test == 5 )
{
pVar = pVar->GivNext();
pVar->SetUserPtr( OBJECTDELETED );
}
return TRUE;
}
CBotTypResult cTEST( CBotVar* &pVar, void* pUser )
{
return CBotTypResult( 0 );
}
// routine retournant le "pointeur" à un autre object
BOOL rF( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
{
if ( pResult == NULL ) return TRUE;
pResult->SetValInt(3);
return TRUE;
}
CBotTypResult cF( CBotVar* &pVar, void* pUser )
{
return CBotTypResult( CBotTypFloat );
}
/////////////////////////////////////////////////////////////////
// Compilation d'une procédure avec un "point".
CBotTypResult cPoint(CBotVar* &var, void* user)
{
if ( var == 0 ) return CBotTypResult( CBotErrLowParam );
if ( var->GivType() <= CBotTypDouble )
{
var = var->GivNext();
if ( var == 0 ) return CBotTypResult( CBotErrLowParam );
if ( var->GivType() > CBotTypDouble ) return CBotTypResult( CBotErrBadNum );
var = var->GivNext();
if ( var == 0 ) return CBotTypResult( CBotErrLowParam );
if ( var->GivType() > CBotTypDouble ) return CBotTypResult( CBotErrBadNum );
var = var->GivNext();
return CBotTypResult( 0 );
}
if ( var->GivType() == CBotTypClass )
{
if ( !var->IsElemOfClass("point") ) return CBotTypResult( CBotErrBadParam );
var = var->GivNext();
return CBotTypResult( 0 );
}
return CBotTypResult( CBotErrBadParam );
}
// Donne un paramètre de type "point".
#define UNIT 1
CBotTypResult cSpace(CBotVar* &var, void* user)
{
CBotTypResult ret;
if ( var == 0 ) return CBotTypResult( CBotTypIntrinsic, "point" );
ret = cPoint(var, user);
if ( !ret.Eq(0) ) return ret;
if ( var == 0 ) return CBotTypIntrinsic;
if ( var->GivType() > CBotTypDouble ) return CBotTypResult( CBotErrBadNum );
var = var->GivNext();
if ( var == 0 ) return CBotTypIntrinsic;
if ( var->GivType() > CBotTypDouble ) return CBotTypResult( CBotErrBadNum );
var = var->GivNext();
if ( var == 0 ) return CBotTypIntrinsic;
if ( var->GivType() > CBotTypDouble ) return CBotTypResult( CBotErrBadNum );
var = var->GivNext();
if ( var != 0 ) return CBotErrOverParam;
return CBotTypResult( CBotTypIntrinsic, "point" );
}
// Instruction "space(center, rMin, rMax, dist)".
BOOL rSpace(CBotVar* var, CBotVar* result, int& exception, void* user)
{
CBotVar* pSub;
float rMin, rMax, dist;
rMin = 5.0f*UNIT;
rMax = 50.0f*UNIT;
dist = 4.0f*UNIT;
if ( var == 0 )
{
// center = pThis->RetPosition(0);
}
else
{
if ( var != 0 )
{
rMin = var->GivValFloat()*UNIT;
var = var->GivNext();
if ( var != 0 )
{
rMax = var->GivValFloat()*UNIT;
var = var->GivNext();
if ( var != 0 )
{
dist = var->GivValFloat()*UNIT;
var = var->GivNext();
}
}
}
}
if ( result != 0 )
{
pSub = result->GivItemList();
if ( pSub != 0 )
{
pSub->SetValFloat(1);
pSub = pSub->GivNext(); // "y"
pSub->SetValFloat(2);
pSub = pSub->GivNext(); // "z"
// pSub->SetValFloat(3);
}
}
return TRUE;
}
//////////////////////////////////////////////////////////////
void CTestCBotDoc::OnTest()
{
CBotProgram::DefineNum("WingedGrabber", 1);
CBotProgram::DefineNum("TrackedGrabber", 2);
CBotProgram::DefineNum("WheeledGrabber", 3);
CBotProgram::DefineNum("LeggedGrabber", 4);
CBotProgram::DefineNum("WingedShooter", 5);
CBotProgram::DefineNum("TrackedShooter", 6);
CBotProgram::DefineNum("WheeledShooter", 7);
CBotProgram::DefineNum("LeggedShooter", 8);
CBotProgram::DefineNum("WingedOrgaShooter", 9);
CBotProgram::DefineNum("TrackedOrgaShooter", 10);
CBotProgram::DefineNum("WheeledOrgaShooter", 11);
CBotProgram::DefineNum("LeggedOrgaShooter", 12);
CBotProgram::DefineNum("WingedSniffer", 13);
CBotProgram::DefineNum("TrackedSniffer", 14);
CBotProgram::DefineNum("WheeledSniffer", 14);
CBotProgram::DefineNum("LeggedSniffer", 15);
CBotProgram::DefineNum("Thumper", 16);
CBotProgram::DefineNum("PhazerShooter", 17);
CBotProgram::DefineNum("Recycler", 18);
CBotProgram::DefineNum("Shielder", 19);
CBotProgram::DefineNum("Subber", 20);
CBotProgram::DefineNum("Me", 21);
CBotProgram::DefineNum("TypeMarkPath", 111);
OnFileSave();
// CPerformDlg dlg;
// dlg.m_Script = m_DocText;
// dlg.DoModal();
// défini la routine RetObject
CBotProgram::AddFunction( "Radar", rRetObject, cRetObject );
// ajoute une routine pour cette classe
CBotProgram::AddFunction("Space", rSpace, cSpace);
// défini la routine Test
CBotProgram::AddFunction( "TEST", rTEST, cTEST );
CBotProgram::AddFunction( "F", rF, cF );
CBotProgram::AddFunction( "goto", rMove, cMove );
CBotProgram::AddFunction( "fire", rTurn, cTurn );
CBotProgram::AddFunction( "radar", rRadar, cRadar );
// crée une instance de la classe "Bot" pour ce robot
CBotVar* pThisRobot = CBotVar::Create( "", CBotTypResult(CBotTypClass, "object") );
pThisRobot->SetUserPtr( (void*)1 );
pThisRobot->SetIdent( 1234 );
delete m_pProg;
// crée un objet programme associé à cette instance
m_pProg = new CBotProgram(pThisRobot);
// compile le programme
CString TextError;
int code, start, end;
m_pEdit->GetWindowText(m_DocText);
if (!m_pProg->Compile(m_DocText, m_Liste, (void*) 44))
{
m_pProg->GetError(code, start, end);
delete m_pProg;
m_pProg = NULL;
delete pThisRobot;
m_pEdit->SetSel( start, end );
m_pEdit->SetFocus(); // met en évidence la partie avec problème
TextError = CBotProgram::GivErrorText( code );
AfxMessageBox( TextError );
m_pEdit->SetFocus();
return;
}
// exécute pour voir
m_pProg->Start(m_Liste[0]);
int mode = -1;
if ( mode >= 0 ) {
// sauve et restore à chaque pas possible
while (!m_pProg->Run(NULL, 1))
{
const char* FunctionName;
int start1, end1;
m_pProg->GetRunPos(FunctionName, start1, end1);
if ( end1 <= 0 )
m_pProg->GetRunPos(FunctionName, start1, end1);
m_pEdit->SetSel(start1, end1);
if ( mode == 0 ) continue;
FILE* pf;
pf = fOpen( "TEST.CBO", "wb" );
CBotClass::SaveStaticState(pf);
m_pProg->SaveState(pf);
fClose(pf);
if ( mode == 2 ) if (!m_pProg->Compile(m_DocText, m_Liste, (void*) 44))
{
m_pProg->GetError(code, start, end);
delete m_pProg;
m_pProg = NULL;
delete pThisRobot;
m_pEdit->SetSel( start, end );
m_pEdit->SetFocus(); // met en évidence la partie avec problème
TextError = CBotProgram::GivErrorText( code );
AfxMessageBox( TextError );
m_pEdit->SetFocus();
return;
}
pf = fOpen( "TEST.CBO", "rb" );
CBotClass::RestoreStaticState(pf);
m_pProg->RestoreState(pf);
fClose(pf);
int start2, end2;
m_pProg->GetRunPos(FunctionName, start2, end2);
if ( end2 <= 0 )
m_pProg->GetRunPos(FunctionName, start2, end2);
if ( start1 != start2 || end1 != end2 )
m_pProg->GetRunPos(FunctionName, start2, end2);
m_pEdit->SetSel(start2, end2);
}
if (m_pProg->GetError(code, start, end))
{
m_pEdit->SetSel(start, end);
TextError = CBotProgram::GivErrorText(code);
AfxMessageBox(TextError);
}
return;}
while (!m_pProg->Run(NULL, 0))
{
const char* FunctionName;
int start, end;
m_pProg->GetRunPos(FunctionName, start, end);
m_pEdit->SetSel(start, end);
if ( FunctionName == NULL ) continue;
CString info (FunctionName);
CString sep (":\n");
int level = 0;
const char* Name;
while ( TRUE )
{
CBotVar* pVar = m_pProg->GivStackVars(Name, level--);
if ( Name != FunctionName ) break;
if ( pVar == NULL ) continue;
// pVar->Maj(NULL, FALSE);
while ( pVar != NULL )
{
info += sep;
info += pVar->GivName() + CBotString(" = ") + pVar->GivValString();
sep = ", ";
pVar = pVar->GivNext();
}
sep = "\n";
}
if ( IDOK != AfxMessageBox(info, MB_OKCANCEL) ) break;
if ( test == 1 )
{
test = 0;
FILE* pf;
pf = fOpen( "TEST.CBO", "wb" );
m_pProg->SaveState(pf);
fClose(pf);
}
if ( test == 2 )
{
test = 0;
FILE* pf;
pf = fOpen( "TEST.CBO", "rb" );
m_pProg->RestoreState(pf);
fClose(pf);
}
if ( test == 12 )
{
test = 0;
FILE* pf;
pf = fOpen( "TEST.CBO", "wb" );
m_pProg->SaveState(pf);
fClose(pf);
pf = fOpen( "TEST.CBO", "rb" );
m_pProg->RestoreState(pf);
fClose(pf);
test = 13;
}
}
if (m_pProg->GetError(code, start, end))
{
m_pEdit->SetSel(start, end);
TextError = CBotProgram::GivErrorText(code);
AfxMessageBox(TextError);
}
delete pThisRobot;
}

78
src/CBot/tests/TestCBot/TestCBotDoc.h
View File

@ -1,78 +0,0 @@
// * This file is part of the COLOBOT source code
// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
// *
// * This program is free software: you can redistribute it and/or modify
// * it under the terms of the GNU General Public License as published by
// * the Free Software Foundation, either version 3 of the License, or
// * (at your option) any later version.
// *
// * This program is distributed in the hope that it will be useful,
// * but WITHOUT ANY WARRANTY; without even the implied warranty of
// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// * GNU General Public License for more details.
// *
// * You should have received a copy of the GNU General Public License
// * along with this program. If not, see http://www.gnu.org/licenses/.// TestCBotDoc.h : interface of the CTestCBotDoc class
//
/////////////////////////////////////////////////////////////////////////////
#if !defined(AFX_TESTCBOTDOC_H__4D1BB90B_8E74_11D4_A439_00D059085115__INCLUDED_)
#define AFX_TESTCBOTDOC_H__4D1BB90B_8E74_11D4_A439_00D059085115__INCLUDED_
#if _MSC_VER >= 1000
#pragma once
#endif // _MSC_VER >= 1000
class CTestCBotDoc : public CDocument
{
protected: // create from serialization only
CTestCBotDoc();
DECLARE_DYNCREATE(CTestCBotDoc)
// Attributes
public:
CEdit* m_pEdit; // pour mémoriser le texte, et l'afficher
CBotProgram* m_pProg; // le programme compilé
CString m_DocText;
CBotStringArray m_Liste;
BOOL m_bModified;
// Operations
public:
BOOL Compile();
// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CTestCBotDoc)
public:
virtual BOOL OnNewDocument();
virtual void Serialize(CArchive& ar);
//}}AFX_VIRTUAL
// Implementation
public:
virtual ~CTestCBotDoc();
#ifdef _DEBUG
virtual void AssertValid() const;
virtual void Dump(CDumpContext& dc) const;
#endif
protected:
// Generated message map functions
protected:
//{{AFX_MSG(CTestCBotDoc)
afx_msg void OnRun();
afx_msg void OnChangeEdit1();
afx_msg void OnTest();
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
/////////////////////////////////////////////////////////////////////////////
//{{AFX_INSERT_LOCATION}}
// Microsoft Developer Studio will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_TESTCBOTDOC_H__4D1BB90B_8E74_11D4_A439_00D059085115__INCLUDED_)

142
src/CBot/tests/TestCBot/TestCBotView.cpp
View File

@ -1,142 +0,0 @@
// * This file is part of the COLOBOT source code
// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
// *
// * This program is free software: you can redistribute it and/or modify
// * it under the terms of the GNU General Public License as published by
// * the Free Software Foundation, either version 3 of the License, or
// * (at your option) any later version.
// *
// * This program is distributed in the hope that it will be useful,
// * but WITHOUT ANY WARRANTY; without even the implied warranty of
// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// * GNU General Public License for more details.
// *
// * You should have received a copy of the GNU General Public License
// * along with this program. If not, see http://www.gnu.org/licenses/.
// TestCBotView.cpp : implementation of the CTestCBotView class
//
#include "stdafx.h"
#include "TestCBot.h"
#include "TestCBotDoc.h"
#include "TestCBotView.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CTestCBotView
IMPLEMENT_DYNCREATE(CTestCBotView, CView)
BEGIN_MESSAGE_MAP(CTestCBotView, CView)
//{{AFX_MSG_MAP(CTestCBotView)
ON_WM_SIZE()
ON_MESSAGE(WM_ACTWINDOW, ActWindow)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CTestCBotView construction/destruction
CTestCBotView::CTestCBotView()
{
}
CTestCBotView::~CTestCBotView()
{
}
BOOL CTestCBotView::PreCreateWindow(CREATESTRUCT& cs)
{
return CView::PreCreateWindow(cs);
}
/////////////////////////////////////////////////////////////////////////////
// CTestCBotView drawing
void CTestCBotView::OnDraw(CDC* pDC)
{
CTestCBotDoc* pDoc = GetDocument();
ASSERT_VALID(pDoc);
}
/////////////////////////////////////////////////////////////////////////////
// CTestCBotView diagnostics
#ifdef _DEBUG
void CTestCBotView::AssertValid() const
{
CView::AssertValid();
}
void CTestCBotView::Dump(CDumpContext& dc) const
{
CView::Dump(dc);
}
CTestCBotDoc* CTestCBotView::GetDocument() // non-debug version is inline
{
ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CTestCBotDoc)));
return (CTestCBotDoc*)m_pDocument;
}
#endif //_DEBUG
/////////////////////////////////////////////////////////////////////////////
// CTestCBotView message handlers
void CTestCBotView::OnActivateView(BOOL bActivate, CView* pActivateView, CView* pDeactiveView)
{
CTestCBotDoc* pDoc = GetDocument();
// CTestCBotApp* pApp = (CTestCBotApp*)AfxGetApp();
if ( pDoc->m_pEdit == NULL)
{
pDoc->m_pEdit = new CEdit();
CRect rect;
GetClientRect( rect );
pDoc->m_pEdit->Create( WS_VISIBLE|WS_BORDER|WS_TABSTOP|ES_MULTILINE|ES_WANTRETURN|ES_NOHIDESEL|ES_AUTOVSCROLL,
rect, this, IDC_EDIT1 );
pDoc->m_pEdit->SetTabStops(12);
pDoc->m_pEdit->SetWindowText(pDoc->m_DocText);
}
if ( !bActivate && !pDoc->Compile() )
{
// comment faire pour réactiver l'ancien document
}
CView::OnActivateView(bActivate, pActivateView, pDeactiveView);
if ( bActivate ) pDoc->m_pEdit->SetFocus();
}
void CTestCBotView::OnSize(UINT nType, int cx, int cy)
{
CView::OnSize(nType, cx, cy);
CTestCBotDoc* pDoc = GetDocument();
if ( pDoc->m_pEdit != NULL )
{
CRect rect;
GetClientRect( rect );
pDoc->m_pEdit->MoveWindow( rect );
pDoc->m_pEdit->SetFocus();
}
}
LONG CTestCBotView::ActWindow(UINT wparam, LONG lparam)
{
// GetParentFrame()->SetActiveView( this, TRUE );
// CMDIChildWnd::OnMDIActivate(1, this, this)
return 0;
}

78
src/CBot/tests/TestCBot/TestCBotView.h
View File

@ -1,78 +0,0 @@
// * This file is part of the COLOBOT source code
// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
// *
// * This program is free software: you can redistribute it and/or modify
// * it under the terms of the GNU General Public License as published by
// * the Free Software Foundation, either version 3 of the License, or
// * (at your option) any later version.
// *
// * This program is distributed in the hope that it will be useful,
// * but WITHOUT ANY WARRANTY; without even the implied warranty of
// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// * GNU General Public License for more details.
// *
// * You should have received a copy of the GNU General Public License
// * along with this program. If not, see http://www.gnu.org/licenses/.// TestCBotView.h : interface of the CTestCBotView class
//
/////////////////////////////////////////////////////////////////////////////
#if !defined(AFX_TESTCBOTVIEW_H__4D1BB90D_8E74_11D4_A439_00D059085115__INCLUDED_)
#define AFX_TESTCBOTVIEW_H__4D1BB90D_8E74_11D4_A439_00D059085115__INCLUDED_
#if _MSC_VER >= 1000
#pragma once
#endif // _MSC_VER >= 1000
class CTestCBotView : public CView
{
protected: // create from serialization only
CTestCBotView();
DECLARE_DYNCREATE(CTestCBotView)
// Attributes
public:
CTestCBotDoc* GetDocument();
// Operations
public:
// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CTestCBotView)
public:
virtual void OnDraw(CDC* pDC); // overridden to draw this view
virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
protected:
virtual void OnActivateView(BOOL bActivate, CView* pActivateView, CView* pDeactiveView);
//}}AFX_VIRTUAL
// Implementation
public:
virtual ~CTestCBotView();
#ifdef _DEBUG
virtual void AssertValid() const;
virtual void Dump(CDumpContext& dc) const;
#endif
protected:
// Generated message map functions
protected:
//{{AFX_MSG(CTestCBotView)
afx_msg void OnSize(UINT nType, int cx, int cy);
afx_msg LONG ActWindow(UINT wparam, LONG lparam) ;
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
#ifndef _DEBUG // debug version in TestCBotView.cpp
inline CTestCBotDoc* CTestCBotView::GetDocument()
{ return (CTestCBotDoc*)m_pDocument; }
#endif
/////////////////////////////////////////////////////////////////////////////
//{{AFX_INSERT_LOCATION}}
// Microsoft Developer Studio will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_TESTCBOTVIEW_H__4D1BB90D_8E74_11D4_A439_00D059085115__INCLUDED_)

96
src/CBot/tests/TestCBot/a�1.txt~
View File

@ -1,96 +0,0 @@
object radarGuepe(point orig, float dist)
{
int i;
object pr, r;
float mindist;
i = 0;
mindist = 1000;
while (i<30)
{
pr = radar(i);
if (pr != null)
{
if (F(orig, pr.position) < mindist and pr.category == AlienWasp and pr.altitude > 3)
{
mindist = distance(orig, pr.position);
r = pr;
}
}
i = i+1;
}
if (mindist < dist) return(r); else return(null);
}
class Guepe
{
point pos;
void cherche(point orig, float dist)
{
object p;
point o;
p = radarGuepe(orig, dist);
while (p == null)
{
wait(0.1);
p = radarGuepe(orig, dist);
}
pos.x = p.position.x;
pos.y = p.position.y;
pos.z = p.position.z;
//o = p.position;
//wait(0.1);
//vitessex = (p.position.x - o.x)/0.1;
//vitessey = (p.position.y - o.y)/0.1;
//vitessez = (p.position.z - o.z)/0.1;
}
void tire(point orig, float orient)
{
//float t = 3; //temps d'anticipation
float angle;
point cible;
cible.x = pos.x;// + t*vitessex;
cible.y = pos.y;// + t*vitessey;
cible.z = pos.z;// + t*vitessez;
if (cible.x == 0) angle = 90; else
angle = atan(cible.y / cible.x);
if (cible.x < 0) angle = angle + 180;
angle = angle - orient;
if (angle > 180) angle = angle - 360;
if (angle < -180) angle = angle + 360;
turn(angle);
angle = atan((cible.z-orig.z) / distance2d(orig, cible));
aim(angle);
fire(0.1);
}
}
extern void object::Fourmi6()
{
//fps(1000);
Guepe guepe = new Guepe();
while (true)
{
guepe.cherche(position, 50);
guepe.tire(position, orientation);
}
}

BIN
src/CBot/tests/TestCBot/res/TestCBot.ico
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 1.1 KiB

13
src/CBot/tests/TestCBot/res/TestCBot.rc2
View File

@ -1,13 +0,0 @@
//
// TESTCBOT.RC2 - resources Microsoft Visual C++ does not edit directly
//
#ifdef APSTUDIO_INVOKED
#error this file is not editable by Microsoft Visual C++
#endif //APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
// Add manually edited resources here...
/////////////////////////////////////////////////////////////////////////////

BIN
src/CBot/tests/TestCBot/res/TestCBotDoc.ico
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 1.1 KiB

BIN
src/CBot/tests/TestCBot/res/Toolbar.bmp
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 1.2 KiB

44
src/CBot/tests/TestCBot/resource.h
View File

@ -1,44 +0,0 @@
// * This file is part of the COLOBOT source code
// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
// *
// * This program is free software: you can redistribute it and/or modify
// * it under the terms of the GNU General Public License as published by
// * the Free Software Foundation, either version 3 of the License, or
// * (at your option) any later version.
// *
// * This program is distributed in the hope that it will be useful,
// * but WITHOUT ANY WARRANTY; without even the implied warranty of
// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// * GNU General Public License for more details.
// *
// * You should have received a copy of the GNU General Public License
// * along with this program. If not, see http://www.gnu.org/licenses/.//{{NO_DEPENDENCIES}}
// Microsoft Developer Studio generated include file.
// Used by TestCBot.rc
//
#define IDD_ABOUTBOX 100
#define IDR_MAINFRAME 128
#define IDR_TESTCBTYPE 129
#define IDD_DIALOG1 130
#define IDD_CONSOLE 131
#define IDD_DIALOG2 133
#define IDC_EDIT1 1000
#define TX_TYPENAMES 1000
#define IDC_SPIN1 1001
#define IDC_EDIT2 1002
#define IDC_COMBO1 1003
#define IDC_EDIT3 1004
#define ID_RUN 32771
#define ID_TEST 32772
// Next default values for new objects
//
#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_3D_CONTROLS 1
#define _APS_NEXT_RESOURCE_VALUE 135
#define _APS_NEXT_COMMAND_VALUE 32773
#define _APS_NEXT_CONTROL_VALUE 1004
#define _APS_NEXT_SYMED_VALUE 101
#endif
#endif

245
src/CBot/tests/TestCBot/xTestCBot.clw
View File

@ -1,245 +0,0 @@
; CLW file contains information for the MFC ClassWizard
[General Info]
Version=1
LastClass=CBotConsoleDlg
LastTemplate=CDialog
NewFileInclude1=#include "stdafx.h"
NewFileInclude2=#include "TestCBot.h"
LastPage=0
ClassCount=7
Class1=CTestCBotApp
Class2=CTestCBotDoc
Class3=CTestCBotView
Class4=CMainFrame
ResourceCount=7
Resource1=IDD_ABOUTBOX
Resource2=IDR_MAINFRAME
Resource3=IDR_TESTCBTYPE
Class5=CAboutDlg
Class6=CChildFrame
Resource4=IDD_ABOUTBOX (French (France))
Resource5=IDR_TESTCBTYPE (French (France))
Resource6=IDD_CONSOLE
Class7=CBotConsoleDlg
Resource7=IDR_MAINFRAME (French (France))
[CLS:CTestCBotApp]
Type=0
HeaderFile=TestCBot.h
ImplementationFile=TestCBot.cpp
Filter=N
[CLS:CTestCBotDoc]
Type=0
HeaderFile=TestCBotDoc.h
ImplementationFile=TestCBotDoc.cpp
Filter=N
BaseClass=CDocument
VirtualFilter=DC
LastObject=IDC_EDIT2
[CLS:CTestCBotView]
Type=0
HeaderFile=TestCBotView.h
ImplementationFile=TestCBotView.cpp
Filter=C
BaseClass=CView
VirtualFilter=VWC
LastObject=CTestCBotView
[CLS:CMainFrame]
Type=0
HeaderFile=MainFrm.h
ImplementationFile=MainFrm.cpp
Filter=T
BaseClass=CMDIFrameWnd
VirtualFilter=fWC
LastObject=CMainFrame
[CLS:CChildFrame]
Type=0
HeaderFile=ChildFrm.h
ImplementationFile=ChildFrm.cpp
Filter=M
[CLS:CAboutDlg]
Type=0
HeaderFile=TestCBot.cpp
ImplementationFile=TestCBot.cpp
Filter=D
[DLG:IDD_ABOUTBOX]
Type=1
ControlCount=4
Control1=IDC_STATIC,static,1342177283
Control2=IDC_STATIC,static,1342308352
Control3=IDC_STATIC,static,1342308352
Control4=IDOK,button,1342373889
Class=CAboutDlg
[MNU:IDR_MAINFRAME]
Type=1
Class=CMainFrame
Command1=ID_FILE_NEW
Command2=ID_FILE_OPEN
Command4=ID_APP_EXIT
Command5=ID_VIEW_TOOLBAR
Command6=ID_VIEW_STATUS_BAR
Command7=ID_APP_ABOUT
CommandCount=7
Command3=ID_FILE_MRU_FILE1
[TB:IDR_MAINFRAME]
Type=1
Class=CMainFrame
Command1=ID_FILE_NEW
Command2=ID_FILE_OPEN
Command3=ID_FILE_SAVE
Command4=ID_EDIT_CUT
Command5=ID_EDIT_COPY
Command6=ID_EDIT_PASTE
Command7=ID_FILE_PRINT
CommandCount=8
Command8=ID_APP_ABOUT
[MNU:IDR_TESTCBTYPE]
Type=1
Class=CTestCBotView
Command1=ID_FILE_NEW
Command2=ID_FILE_OPEN
Command3=ID_FILE_CLOSE
Command4=ID_FILE_SAVE
Command5=ID_FILE_SAVE_AS
Command9=ID_EDIT_CUT
Command10=ID_EDIT_COPY
Command11=ID_EDIT_PASTE
Command12=ID_VIEW_TOOLBAR
Command13=ID_VIEW_STATUS_BAR
Command14=ID_WINDOW_NEW
CommandCount=18
Command6=ID_FILE_MRU_FILE1
Command7=ID_APP_EXIT
Command8=ID_EDIT_UNDO
Command15=ID_WINDOW_CASCADE
Command16=ID_WINDOW_TILE_HORZ
Command17=ID_WINDOW_ARRANGE
Command18=ID_APP_ABOUT
[ACL:IDR_MAINFRAME]
Type=1
Class=CMainFrame
Command1=ID_FILE_NEW
Command2=ID_FILE_OPEN
Command3=ID_FILE_SAVE
Command5=ID_EDIT_CUT
Command6=ID_EDIT_COPY
Command7=ID_EDIT_PASTE
Command8=ID_EDIT_UNDO
Command9=ID_EDIT_CUT
Command10=ID_EDIT_COPY
Command11=ID_EDIT_PASTE
Command12=ID_NEXT_PANE
CommandCount=13
Command4=ID_EDIT_UNDO
Command13=ID_PREV_PANE
[TB:IDR_MAINFRAME (French (France))]
Type=1
Class=?
Command1=ID_FILE_NEW
Command2=ID_FILE_OPEN
Command3=ID_FILE_SAVE
Command4=ID_EDIT_CUT
Command5=ID_EDIT_COPY
Command6=ID_EDIT_PASTE
Command7=ID_FILE_PRINT
Command8=ID_RUN
Command9=ID_APP_ABOUT
CommandCount=9
[MNU:IDR_MAINFRAME (French (France))]
Type=1
Class=?
Command1=ID_FILE_NEW
Command2=ID_FILE_OPEN
Command3=ID_FILE_MRU_FILE1
Command4=ID_APP_EXIT
Command5=ID_VIEW_TOOLBAR
Command6=ID_VIEW_STATUS_BAR
Command7=ID_APP_ABOUT
CommandCount=7
[MNU:IDR_TESTCBTYPE (French (France))]
Type=1
Class=?
Command1=ID_FILE_NEW
Command2=ID_FILE_OPEN
Command3=ID_FILE_CLOSE
Command4=ID_FILE_SAVE
Command5=ID_FILE_SAVE_AS
Command6=ID_FILE_MRU_FILE1
Command7=ID_APP_EXIT
Command8=ID_EDIT_UNDO
Command9=ID_EDIT_CUT
Command10=ID_EDIT_COPY
Command11=ID_EDIT_PASTE
Command12=ID_VIEW_TOOLBAR
Command13=ID_VIEW_STATUS_BAR
Command14=ID_WINDOW_NEW
Command15=ID_WINDOW_CASCADE
Command16=ID_WINDOW_TILE_HORZ
Command17=ID_WINDOW_ARRANGE
Command18=ID_APP_ABOUT
CommandCount=18
[ACL:IDR_MAINFRAME (French (France))]
Type=1
Class=?
Command1=ID_EDIT_COPY
Command2=ID_FILE_NEW
Command3=ID_FILE_OPEN
Command4=ID_FILE_SAVE
Command5=ID_EDIT_PASTE
Command6=ID_EDIT_UNDO
Command7=ID_EDIT_CUT
Command8=ID_RUN
Command9=ID_NEXT_PANE
Command10=ID_PREV_PANE
Command11=ID_RUN
Command12=ID_EDIT_COPY
Command13=ID_EDIT_PASTE
Command14=ID_EDIT_CUT
Command15=ID_EDIT_UNDO
CommandCount=15
[DLG:IDD_ABOUTBOX (French (France))]
Type=1
Class=CAboutDlg
ControlCount=4
Control1=IDC_STATIC,static,1342177283
Control2=IDC_STATIC,static,1342308480
Control3=IDC_STATIC,static,1342308352
Control4=IDOK,button,1342373889
[DLG:IDD_CONSOLE]
Type=1
Class=CBotConsoleDlg
ControlCount=4
Control1=IDC_STATIC,static,1342308352
Control2=IDC_EDIT2,edit,1350631552
Control3=IDOK,button,1342242817
Control4=IDC_EDIT1,edit,1352734724
[CLS:CBotConsoleDlg]
Type=0
HeaderFile=CBotConsoleDlg.h
ImplementationFile=CBotConsoleDlg.cpp
BaseClass=CDialog
Filter=D
VirtualFilter=dWC

96
src/CBot/tests/scenarios/a1.txt
View File

@ -1,96 +0,0 @@
object radarGuepe(point orig, float dist)
{
int i;
object pr, r;
float mindist;
i = 0;
mindist = 1000;
while (i<30)
{
pr = radar(i);
if (pr != null)
{
if (F(orig, pr.position) < mindist and pr.category == AlienWasp and pr.altitude > 3)
{
mindist = distance(orig, pr.position);
r = pr;
}
}
i = i+1;
}
if (mindist < dist) return(r); else return(null);
}
class Guepe
{
point pos;
void cherche(point orig, float dist)
{
object p;
point o;
p = radarGuepe(orig, dist);
while (p == null)
{
wait(0.1);
p = radarGuepe(orig, dist);
}
pos.x = p.position.x;
pos.y = p.position.y;
pos.z = p.position.z;
//o = p.position;
//wait(0.1);
//vitessex = (p.position.x - o.x)/0.1;
//vitessey = (p.position.y - o.y)/0.1;
//vitessez = (p.position.z - o.z)/0.1;
}
void tire(point orig, float orient)
{
//float t = 3; //temps d'anticipation
float angle;
point cible;
cible.x = pos.x;// + t*vitessex;
cible.y = pos.y;// + t*vitessey;
cible.z = pos.z;// + t*vitessez;
if (cible.x == 0) angle = 90; else
angle = atan(cible.y / cible.x);
if (cible.x < 0) angle = angle + 180;
angle = angle - orient;
if (angle > 180) angle = angle - 360;
if (angle < -180) angle = angle + 360;
turn(angle);
angle = atan((cible.z-orig.z) / distance2d(orig, cible));
aim(angle);
fire(0.1);
}
}
extern void object::Fourmi6()
{
//fps(1000);
Guepe guepe = new Guepe();
while (true)
{
guepe.cherche(position, 50);
guepe.tire(position, orientation);
}
}

24
src/CBot/tests/scenarios/array.txt
View File

@ -1,24 +0,0 @@
public extern void TestTableau ()
{
int tableau [ 12 ] ;
point array[ 12 ] [ 14 ] ;
point zéro ( 1, 2 ) ;
point a = zéro ;
for ( int i = 0 ; i < 10 ; i++ ) array[ i ] [ i ]= zéro ;
array[ 5 ] [3 ] . x =1.5 ;
array[ 2 ] [ 2 ] . y = array[ 5 ] [ 5 ] . x ;
array[ 4 ] = array [ 2 ] ;
for ( int i = 0 ; i < 10 ; i++ ) for ( int j = 0 ; j < 4 ; j++ ) println ( i, j, array [ i ] [ j ] ) ;
show( zéro, a, array );
}

96
src/CBot/tests/scenarios/a�1.txt
View File

@ -1,96 +0,0 @@
object radarGuepe(point orig, float dist)
{
int i;
object pr, r;
float mindist;
i = 0;
mindist = 1000;
while (i<30)
{
pr = radar(i);
if (pr != null)
{
if (F(orig, pr.position) < mindist and pr.category == AlienWasp and pr.altitude > 3)
{
mindist = distance(orig, pr.position);
r = pr;
}
}
i = i+1;
}
if (mindist < dist) return(r); else return(null);
}
class Guepe
{
point pos;
void cherche(point orig, float dist)
{
object p;
point o;
p = radarGuepe(orig, dist);
while (p == null)
{
wait(0.1);
p = radarGuepe(orig, dist);
}
pos.x = p.position.x;
pos.y = p.position.y;
pos.z = p.position.z;
//o = p.position;
//wait(0.1);
//vitessex = (p.position.x - o.x)/0.1;
//vitessey = (p.position.y - o.y)/0.1;
//vitessez = (p.position.z - o.z)/0.1;
}
void tire(point orig, float orient)
{
//float t = 3; //temps d'anticipation
float angle;
point cible;
cible.x = pos.x;// + t*vitessex;
cible.y = pos.y;// + t*vitessey;
cible.z = pos.z;// + t*vitessez;
if (cible.x == 0) angle = 90; else
angle = atan(cible.y / cible.x);
if (cible.x < 0) angle = angle + 180;
angle = angle - orient;
if (angle > 180) angle = angle - 360;
if (angle < -180) angle = angle + 360;
turn(angle);
angle = atan((cible.z-orig.z) / distance2d(orig, cible));
aim(angle);
fire(0.1);
}
}
extern void object::Fourmi6()
{
//fps(1000);
Guepe guepe = new Guepe();
while (true)
{
guepe.cherche(position, 50);
guepe.tire(position, orientation);
}
}

96
src/CBot/tests/scenarios/a�1.txt
View File

@ -1,96 +0,0 @@
object radarGuepe(point orig, float dist)
{
int i;
object pr, r;
float mindist;
i = 0;
mindist = 1000;
while (i<30)
{
pr = radar(i);
if (pr != null)
{
if (F(orig, pr.position) < mindist and pr.category == AlienWasp and pr.altitude > 3)
{
mindist = distance(orig, pr.position);
r = pr;
}
}
i = i+1;
}
if (mindist < dist) return(r); else return(null);
}
class Guepe
{
point pos;
void cherche(point orig, float dist)
{
object p;
point o;
p = radarGuepe(orig, dist);
while (p == null)
{
wait(0.1);
p = radarGuepe(orig, dist);
}
pos.x = p.position.x;
pos.y = p.position.y;
pos.z = p.position.z;
//o = p.position;
//wait(0.1);
//vitessex = (p.position.x - o.x)/0.1;
//vitessey = (p.position.y - o.y)/0.1;
//vitessez = (p.position.z - o.z)/0.1;
}
void tire(point orig, float orient)
{
//float t = 3; //temps d'anticipation
float angle;
point cible;
cible.x = pos.x;// + t*vitessex;
cible.y = pos.y;// + t*vitessey;
cible.z = pos.z;// + t*vitessez;
if (cible.x == 0) angle = 90; else
angle = atan(cible.y / cible.x);
if (cible.x < 0) angle = angle + 180;
angle = angle - orient;
if (angle > 180) angle = angle - 360;
if (angle < -180) angle = angle + 360;
turn(angle);
angle = atan((cible.z-orig.z) / distance2d(orig, cible));
aim(angle);
fire(0.1);
}
}
extern void object::Fourmi6()
{
//fps(1000);
Guepe guepe = new Guepe();
while (true)
{
guepe.cherche(position, 50);
guepe.tire(position, orientation);
}
}

8
src/CMakeLists.txt
View File

@ -14,14 +14,6 @@ add_subdirectory(po)
add_subdirectory(desktop)
# Tests
if(${TESTS})
add_subdirectory(common/test)
add_subdirectory(graphics/engine/test)
add_subdirectory(ui/test)
add_subdirectory(math/test)
endif()
# Optional libraries
set(OPTIONAL_LIBS "")

22
src/common/test/CMakeLists.txt
View File

@ -1,22 +0,0 @@
cmake_minimum_required(VERSION 2.8)
if(NOT CMAKE_BUILD_TYPE)
set(CMAKE_BUILD_TYPE debug)
endif(NOT CMAKE_BUILD_TYPE)
set(CMAKE_CXX_FLAGS_DEBUG "-g -O0")
include_directories(
.
../..
../../..
${GTEST_INCLUDE_DIR}
)
add_executable(image_test ../image.cpp image_test.cpp)
target_link_libraries(image_test ${SDL_LIBRARY} ${SDLIMAGE_LIBRARY} ${PNG_LIBRARIES})
#add_executable(profile_test ../profile.cpp ../logger.cpp profile_test.cpp)
#target_link_libraries(profile_test gtest ${Boost_LIBRARIES})
#add_test(profile_test ./profile_test)

90
src/graphics/opengl/test/CMakeLists.txt
View File

@ -1,90 +0,0 @@
cmake_minimum_required(VERSION 2.8)
find_package(OpenGL REQUIRED)
find_package(SDL REQUIRED)
find_package(SDL_image REQUIRED)
find_package(PNG REQUIRED)
if(NOT CMAKE_BUILD_TYPE)
set(CMAKE_BUILD_TYPE debug)
endif(NOT CMAKE_BUILD_TYPE)
set(CMAKE_CXX_FLAGS_DEBUG "-g -O0")
set(ADD_LIBS "")
if (${CMAKE_SYSTEM_NAME} MATCHES "Windows")
set(PLATFORM_WINDOWS 1)
set(PLATFORM_LINUX 0)
set(PLATFORM_OTHER 0)
elseif(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
set(PLATFORM_WINDOWS 0)
set(PLATFORM_LINUX 1)
set(PLATFORM_OTHER 0)
set(ADD_LIBS "-lrt")
else()
set(PLATFORM_WINDOWS 0)
set(PLATFORM_LINUX 0)
set(PLATFORM_OTHER 1)
endif()
configure_file(../../../common/config.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/common/config.h)
set(TEXTURE_SOURCES
../gldevice.cpp
../../../common/logger.cpp
../../../common/image.cpp
texture_test.cpp
)
set(MODEL_SOURCES
../gldevice.cpp
../../engine/modelfile.cpp
../../../common/logger.cpp
../../../common/image.cpp
../../../common/iman.cpp
../../../common/stringutils.cpp
../../../app/system.cpp
model_test.cpp
)
set(TRANSFORM_SOURCES
../gldevice.cpp
../../../common/logger.cpp
../../../common/image.cpp
../../../common/iman.cpp
../../../app/system.cpp
transform_test.cpp
)
set(LIGHT_SOURCES
../gldevice.cpp
../../../common/logger.cpp
../../../common/image.cpp
../../../common/iman.cpp
../../../app/system.cpp
light_test.cpp
)
include_directories(../../../ ${CMAKE_CURRENT_BINARY_DIR})
set(LIBS
${SDL_LIBRARY}
${SDLIMAGE_LIBRARY}
${OPENGL_LIBRARY}
${PNG_LIBRARIES}
${ADD_LIBS}
)
add_executable(texture_test ${TEXTURE_SOURCES})
target_link_libraries(texture_test ${LIBS})
# Temporarily disabling because of dependencies on CEngine et al.
#add_executable(model_test ${MODEL_SOURCES})
#target_link_libraries(model_test ${LIBS})
add_executable(transform_test ${TRANSFORM_SOURCES})
target_link_libraries(transform_test ${LIBS})
add_executable(light_test ${LIGHT_SOURCES})
target_link_libraries(light_test ${LIBS})

26
src/math/test/CMakeLists.txt
View File

@ -1,26 +0,0 @@
cmake_minimum_required(VERSION 2.8)
if(NOT CMAKE_BUILD_TYPE)
set(CMAKE_BUILD_TYPE debug)
endif(NOT CMAKE_BUILD_TYPE)
set(CMAKE_CXX_FLAGS_DEBUG "-g -O0")
include_directories(
.
../..
../../..
${GTEST_INCLUDE_DIR}
)
add_executable(matrix_test matrix_test.cpp)
target_link_libraries(matrix_test gtest)
add_executable(vector_test vector_test.cpp)
target_link_libraries(vector_test gtest)
add_executable(geometry_test geometry_test.cpp)
target_link_libraries(geometry_test gtest)
add_test(matrix_test matrix_test)
add_test(vector_test vector_test)
add_test(geometry_test geometry_test)

36
src/ui/test/CMakeLists.txt
View File

@ -1,36 +0,0 @@
cmake_minimum_required(VERSION 2.8)
if(NOT CMAKE_BUILD_TYPE)
set(CMAKE_BUILD_TYPE debug)
endif(NOT CMAKE_BUILD_TYPE)
set(CMAKE_CXX_FLAGS_DEBUG "-g -O0")
include_directories(
.
../..
../../..
${GTEST_INCLUDE_DIR}
${GMOCK_INCLUDE_DIR}
)
add_executable(edit_test
../../common/event.cpp
../../common/logger.cpp
../../common/misc.cpp
../../common/iman.cpp
../../common/stringutils.cpp
../../graphics/engine/text.cpp
../button.cpp
../control.cpp
../edit.cpp
../scroll.cpp
stubs/app_stub.cpp
stubs/engine_stub.cpp
stubs/particle_stub.cpp
stubs/restext_stub.cpp
stubs/robotmain_stub.cpp
edit_test.cpp)
target_link_libraries(edit_test gtest gmock ${SDL_LIBRARY} ${SDLTTF_LIBRARY} ${Boost_LIBRARIES})
add_test(edit_test ./edit_test)

291
src/ui/test/stubs/particle_stub.cpp
View File

@ -1,291 +0,0 @@
#include "graphics/engine/particle.h"
#include "common/logger.h"
// Graphics module namespace
namespace Gfx {
CParticle::CParticle(CInstanceManager* iMan, CEngine* engine)
{
GetLogger()->Trace("CParticle::CParticle() stub!\n");
// TODO!
}
CParticle::~CParticle()
{
GetLogger()->Trace("CParticle::~CParticle() stub!\n");
// TODO!
}
void CParticle::SetDevice(CDevice* device)
{
GetLogger()->Trace("CParticle::SetDevice() stub!\n");
// TODO!
}
void CParticle::FlushParticle()
{
GetLogger()->Trace("CParticle::FlushParticle() stub!\n");
// TODO!
}
void CParticle::FlushParticle(int sheet)
{
GetLogger()->Trace("CParticle::FlushParticle() stub!\n");
// TODO!
}
int CParticle::CreateParticle(Math::Vector pos, Math::Vector speed, Math::Point dim,
ParticleType type, float duration, float mass,
float windSensitivity, int sheet)
{
GetLogger()->Trace("CParticle::CreateParticle() stub!\n");
// TODO!
return 0;
}
int CParticle::CreateFrag(Math::Vector pos, Math::Vector speed, EngineTriangle *triangle,
ParticleType type, float duration, float mass,
float windSensitivity, int sheet)
{
GetLogger()->Trace("CParticle::CreateFrag() stub!\n");
// TODO!
return 0;
}
int CParticle::CreatePart(Math::Vector pos, Math::Vector speed, ParticleType type,
float duration, float mass, float weight,
float windSensitivity, int sheet)
{
GetLogger()->Trace("CParticle::CreatePart() stub!\n");
// TODO!
return 0;
}
int CParticle::CreateRay(Math::Vector pos, Math::Vector goal, ParticleType type, Math::Point dim,
float duration, int sheet)
{
GetLogger()->Trace("CParticle::CreateRay() stub!\n");
// TODO!
return 0;
}
int CParticle::CreateTrack(Math::Vector pos, Math::Vector speed, Math::Point dim, ParticleType type,
float duration, float mass, float length, float width)
{
GetLogger()->Trace("CParticle::CreateTrack() stub!\n");
// TODO!
return 0;
}
void CParticle::CreateWheelTrace(const Math::Vector &p1, const Math::Vector &p2, const Math::Vector &p3,
const Math::Vector &p4, ParticleType type)
{
GetLogger()->Trace("CParticle::CreateWheelTrace() stub!\n");
// TODO!
}
void CParticle::DeleteParticle(ParticleType type)
{
GetLogger()->Trace("CParticle::DeleteParticle() stub!\n");
// TODO!
}
void CParticle::DeleteParticle(int channel)
{
GetLogger()->Trace("CParticle::DeleteParticle() stub!\n");
// TODO!
}
void CParticle::SetObjectLink(int channel, CObject *object)
{
GetLogger()->Trace("CParticle::SetObjectLink() stub!\n");
// TODO!
}
void CParticle::SetObjectFather(int channel, CObject *object)
{
GetLogger()->Trace("CParticle::SetObjectFather() stub!\n");
// TODO!
}
void CParticle::SetPosition(int channel, Math::Vector pos)
{
GetLogger()->Trace("CParticle::SetPosition() stub!\n");
// TODO!
}
void CParticle::SetDimension(int channel, Math::Point dim)
{
GetLogger()->Trace("CParticle::SetDimension() stub!\n");
// TODO!
}
void CParticle::SetZoom(int channel, float zoom)
{
GetLogger()->Trace("CParticle::SetZoom() stub!\n");
// TODO!
}
void CParticle::SetAngle(int channel, float angle)
{
GetLogger()->Trace("CParticle::SetAngle() stub!\n");
// TODO!
}
void CParticle::SetIntensity(int channel, float intensity)
{
GetLogger()->Trace("CParticle::SetIntensity() stub!\n");
// TODO!
}
void CParticle::SetParam(int channel, Math::Vector pos, Math::Point dim, float zoom, float angle, float intensity)
{
GetLogger()->Trace("CParticle::SetParam() stub!\n");
// TODO!
}
void CParticle::SetPhase(int channel, ParticlePhase phase, float duration)
{
GetLogger()->Trace("CParticle::SetPhase() stub!\n");
// TODO!
}
bool CParticle::GetPosition(int channel, Math::Vector &pos)
{
GetLogger()->Trace("CParticle::GetPosition() stub!\n");
// TODO!
return true;
}
Color CParticle::GetFogColor(Math::Vector pos)
{
GetLogger()->Trace("CParticle::GetFogColor() stub!\n");
// TODO!
return Color();
}
void CParticle::SetFrameUpdate(int sheet, bool update)
{
GetLogger()->Trace("CParticle::SetFrameUpdate() stub!\n");
// TODO!
}
void CParticle::FrameParticle(float rTime)
{
GetLogger()->Trace("CParticle::FrameParticle() stub!\n");
// TODO!
}
void CParticle::DrawParticle(int sheet)
{
GetLogger()->Trace("CParticle::DrawParticle() stub!\n");
// TODO!
}
bool CParticle::WriteWheelTrace(const char *filename, int width, int height, Math::Vector dl, Math::Vector ur)
{
GetLogger()->Trace("CParticle::WriteWheelTrace() stub!\n");
// TODO!
return true;
}
void CParticle::DeleteRank(int rank)
{
GetLogger()->Trace("CParticle::DeleteRank() stub!\n");
// TODO!
}
bool CParticle::CheckChannel(int &channel)
{
GetLogger()->Trace("CParticle::CheckChannel() stub!\n");
// TODO!
return true;
}
void CParticle::DrawParticleTriangle(int i)
{
GetLogger()->Trace("CParticle::DrawParticleTriangle() stub!\n");
// TODO!
}
void CParticle::DrawParticleNorm(int i)
{
GetLogger()->Trace("CParticle::DrawParticleNorm() stub!\n");
// TODO!
}
void CParticle::DrawParticleFlat(int i)
{
GetLogger()->Trace("CParticle::DrawParticleFlat() stub!\n");
// TODO!
}
void CParticle::DrawParticleFog(int i)
{
GetLogger()->Trace("CParticle::DrawParticleFog() stub!\n");
// TODO!
}
void CParticle::DrawParticleRay(int i)
{
GetLogger()->Trace("CParticle::DrawParticleRay() stub!\n");
// TODO!
}
void CParticle::DrawParticleSphere(int i)
{
GetLogger()->Trace("CParticle::DrawParticleSphere() stub!\n");
// TODO!
}
void CParticle::DrawParticleCylinder(int i)
{
GetLogger()->Trace("CParticle::DrawParticleCylinder() stub!\n");
// TODO!
}
void CParticle::DrawParticleWheel(int i)
{
GetLogger()->Trace("CParticle::DrawParticleWheel() stub!\n");
// TODO!
}
CObject* CParticle::SearchObjectGun(Math::Vector old, Math::Vector pos, ParticleType type, CObject *father)
{
GetLogger()->Trace("CParticle::SearchObjectGun() stub!\n");
// TODO!
return nullptr;
}
CObject* CParticle::SearchObjectRay(Math::Vector pos, Math::Vector goal, ParticleType type, CObject *father)
{
GetLogger()->Trace("CParticle::SearchObjectRay() stub!\n");
// TODO!
return nullptr;
}
void CParticle::Play(Sound sound, Math::Vector pos, float amplitude)
{
GetLogger()->Trace("CParticle::Play() stub!\n");
// TODO!
}
bool CParticle::TrackMove(int i, Math::Vector pos, float progress)
{
GetLogger()->Trace("CParticle::TrackMove() stub!\n");
// TODO!
return true;
}
void CParticle::TrackDraw(int i, ParticleType type)
{
GetLogger()->Trace("CParticle::TrackDraw() stub!\n");
// TODO!
}
} // namespace Gfx

13
test/CMakeLists.txt Normal file
View File

@ -0,0 +1,13 @@
# Compile flags as defined in global CMakeLists
set(CMAKE_CXX_FLAGS "${COLOBOT_CXX_FLAGS} ${MXE_CFLAGS}")
set(CMAKE_CXX_FLAGS_RELEASE ${COLOBOT_CXX_FLAGS_RELEASE})
set(CMAKE_CXX_FLAGS_DEBUG ${COLOBOT_CXX_FLAGS_DEBUG})
# CBot utils
add_subdirectory(cbot)
# Unit tests
add_subdirectory(unit)
# Test environments
add_subdirectory(envs)

0
src/CBot/tests/CBot_console/src/app/CBotConsole.cpp → test/cbot/CBot_console/CBotConsole.cpp
View File

0
src/CBot/tests/CBot_console/src/app/CBotConsole.h → test/cbot/CBot_console/CBotConsole.h
View File

0
src/CBot/tests/CBot_console/src/app/CBotDoc.cpp → test/cbot/CBot_console/CBotDoc.cpp
View File

0
src/CBot/tests/CBot_console/src/app/CBotDoc.h → test/cbot/CBot_console/CBotDoc.h
View File

0
src/CBot/tests/CBot_console/src/app/CClass.cpp → test/cbot/CBot_console/CClass.cpp
View File

0
src/CBot/tests/CBot_console/src/app/CClass.h → test/cbot/CBot_console/CClass.h
View File

16
test/cbot/CBot_console/CMakeLists.txt Normal file
View File

@ -0,0 +1,16 @@
set(SOURCES
CClass.cpp
main.cpp
CBotDoc.cpp
CBotConsole.cpp
)
set(LIBS
CBot
)
include_directories(${colobot_SOURCE_DIR}/src)
add_executable(CBot_console ${SOURCES})
target_link_libraries(CBot_console ${LIBS})

0
src/CBot/tests/CBot_console/src/app/main.cpp → test/cbot/CBot_console/main.cpp
View File

0
src/CBot/tests/CBot_console/src/app/routines.cpp → test/cbot/CBot_console/routines.cpp
View File

2
test/cbot/CMakeLists.txt Normal file
View File

@ -0,0 +1,2 @@
# CBot console interpreter
add_subdirectory(CBot_console)

0
src/CBot/tests/scenarios/B.txt → test/cbot/scenarios/B.txt
View File

0
src/CBot/tests/scenarios/BUG2.txt → test/cbot/scenarios/BUG2.txt
View File

0
src/CBot/tests/scenarios/Deleted.txt → test/cbot/scenarios/Deleted.txt
View File

0
src/CBot/tests/scenarios/MaClass.txt → test/cbot/scenarios/MaClass.txt
View File

0
src/CBot/tests/scenarios/Mc2.txt → test/cbot/scenarios/Mc2.txt
View File

0
src/CBot/tests/scenarios/Mon fichier.txt → test/cbot/scenarios/Mon fichier.txt
View File

0
src/CBot/tests/scenarios/Nop.txt → test/cbot/scenarios/Nop.txt
View File

0
src/CBot/tests/scenarios/POS.txt → test/cbot/scenarios/POS.txt
View File

0
src/CBot/tests/scenarios/T.txt → test/cbot/scenarios/T.txt
View File

0
src/CBot/tests/scenarios/TESTALL.txt → test/cbot/scenarios/TESTALL.txt
View File

0
src/CBot/tests/scenarios/TestCB1.txt → test/cbot/scenarios/TestCB1.txt
View File

0
src/CBot/tests/scenarios/TestCBot1.txt → test/cbot/scenarios/TestCBot1.txt
View File

0
src/CBot/tests/scenarios/TestCBot3.txt → test/cbot/scenarios/TestCBot3.txt
View File

0
src/CBot/tests/scenarios/TestNull.txt → test/cbot/scenarios/TestNull.txt
View File

0
src/CBot/tests/scenarios/TestRestoreState.txt → test/cbot/scenarios/TestRestoreState.txt
View File

0
src/CBot/tests/scenarios/TestStatic.txt → test/cbot/scenarios/TestStatic.txt
View File

0
src/CBot/tests/scenarios/TestStr.txt → test/cbot/scenarios/TestStr.txt
View File

0
src/CBot/tests/scenarios/Z.txt → test/cbot/scenarios/Z.txt
View File

312
test/cbot/scenarios/a.txt Normal file
View File

@ -0,0 +1,312 @@
object radarGuepe(point orig, float dist)
{
int i;
object pr, r;
float mindist;
i = 0;
mindist = 1000;
while (i<30)
{
pr = radar(i);
if (pr != null)
{
if (F(orig, pr.position) < mindist and pr.category == AlienWasp and pr.altitude > 3)
{
mindist = distance(orig, pr.position);
r = pr;
}
}
i = i+1;
}
if (mindist < dist) return(r); else return(null);
}
class Guepe
{
point pos;
void cherche(point orig, float dist)
{
object p;
point o;
p = radarGuepe(orig, dist);
while (p == null)
{
wait(0.1);
p = radarGuepe(orig, dist);
}
pos.x = p.position.x;
pos.y = p.position.y;
pos.z = p.position.z;
//o = p.position;
//wait(0.1);
//vitessex = (p.position.x - o.x)/0.1;
//vitessey = (p.position.y - o.y)/0.1;
//vitessez = (p.position.z - o.z)/0.1;
}
void tire(point orig, float orient)
{
//float t = 3; //temps d'anticipation
float angle;
point cible;
cible.x = pos.x;// + t*vitessex;
cible.y = pos.y;// + t*vitessey;
cible.z = pos.z;// + t*vitessez;
if (cible.x == 0) angle = 90; else
angle = atan(cible.y / cible.x);
if (cible.x < 0) angle = angle + 180;
angle = angle - orient;
if (angle > 180) angle = angle - 360;
if (angle < -180) angle = angle + 360;
turn(angle);
angle = atan((cible.z-orig.z) / distance2d(orig, cible));
aim(angle);
fire(0.1);
}
}
extern void object::Fourmi6()
{
//fps(1000);
Guepe guepe = new Guepe();
while (true)
{
guepe.cherche(position, 50);
guepe.tire(position, orientation);
}
}
object radarGuepe(point orig, float dist)
{
int i;
object pr, r;
float mindist;
i = 0;
mindist = 1000;
while (i<30)
{
pr = radar(i);
if (pr != null)
{
if (F(orig, pr.position) < mindist and pr.category == AlienWasp and pr.altitude > 3)
{
mindist = distance(orig, pr.position);
r = pr;
}
}
i = i+1;
}
if (mindist < dist) return(r); else return(null);
}
class Guepe
{
point pos;
void cherche(point orig, float dist)
{
object p;
point o;
p = radarGuepe(orig, dist);
while (p == null)
{
wait(0.1);
p = radarGuepe(orig, dist);
}
pos.x = p.position.x;
pos.y = p.position.y;
pos.z = p.position.z;
//o = p.position;
//wait(0.1);
//vitessex = (p.position.x - o.x)/0.1;
//vitessey = (p.position.y - o.y)/0.1;
//vitessez = (p.position.z - o.z)/0.1;
}
void tire(point orig, float orient)
{
//float t = 3; //temps d'anticipation
float angle;
point cible;
cible.x = pos.x;// + t*vitessex;
cible.y = pos.y;// + t*vitessey;
cible.z = pos.z;// + t*vitessez;
if (cible.x == 0) angle = 90; else
angle = atan(cible.y / cible.x);
if (cible.x < 0) angle = angle + 180;
angle = angle - orient;
if (angle > 180) angle = angle - 360;
if (angle < -180) angle = angle + 360;
turn(angle);
angle = atan((cible.z-orig.z) / distance2d(orig, cible));
aim(angle);
fire(0.1);
}
}
extern void object::Fourmi6()
{
//fps(1000);
Guepe guepe = new Guepe();
while (true)
{
guepe.cherche(position, 50);
guepe.tire(position, orientation);
}
}
object radarGuepe(point orig, float dist)
{
int i;
object pr, r;
float mindist;
i = 0;
mindist = 1000;
while (i<30)
{
pr = radar(i);
if (pr != null)
{
if (F(orig, pr.position) < mindist and pr.category == AlienWasp and pr.altitude > 3)
{
mindist = distance(orig, pr.position);
r = pr;
}
}
i = i+1;
}
if (mindist < dist) return(r); else return(null);
}
class Guepe
{
point pos;
void cherche(point orig, float dist)
{
object p;
point o;
p = radarGuepe(orig, dist);
while (p == null)
{
wait(0.1);
p = radarGuepe(orig, dist);
}
pos.x = p.position.x;
pos.y = p.position.y;
pos.z = p.position.z;
//o = p.position;
//wait(0.1);
//vitessex = (p.position.x - o.x)/0.1;
//vitessey = (p.position.y - o.y)/0.1;
//vitessez = (p.position.z - o.z)/0.1;
}
void tire(point orig, float orient)
{
//float t = 3; //temps d'anticipation
float angle;
point cible;
cible.x = pos.x;// + t*vitessex;
cible.y = pos.y;// + t*vitessey;
cible.z = pos.z;// + t*vitessez;
if (cible.x == 0) angle = 90; else
angle = atan(cible.y / cible.x);
if (cible.x < 0) angle = angle + 180;
angle = angle - orient;
if (angle > 180) angle = angle - 360;
if (angle < -180) angle = angle + 360;
turn(angle);
angle = atan((cible.z-orig.z) / distance2d(orig, cible));
aim(angle);
fire(0.1);
}
}
extern void object::Fourmi6()
{
//fps(1000);
Guepe guepe = new Guepe();
while (true)
{
guepe.cherche(position, 50);
guepe.tire(position, orientation);
}
}
public extern void TestTableau ()
{
int tableau [ 12 ] ;
point array[ 12 ] [ 14 ] ;
point zéro ( 1, 2 ) ;
point a = zéro ;
for ( int i = 0 ; i < 10 ; i++ ) array[ i ] [ i ]= zéro ;
array[ 5 ] [3 ] . x =1.5 ;
array[ 2 ] [ 2 ] . y = array[ 5 ] [ 5 ] . x ;
array[ 4 ] = array [ 2 ] ;
for ( int i = 0 ; i < 10 ; i++ ) for ( int j = 0 ; j < 4 ; j++ ) println ( i, j, array [ i ] [ j ] ) ;
show( zéro, a, array );
}

0
src/CBot/tests/scenarios/bug.txt → test/cbot/scenarios/bug.txt
View File

0
src/CBot/tests/scenarios/bugmw.txt → test/cbot/scenarios/bugmw.txt
View File

0
src/CBot/tests/scenarios/ccc.txt → test/cbot/scenarios/ccc.txt
View File

0
src/CBot/tests/scenarios/enum.txt → test/cbot/scenarios/enum.txt
View File

0
src/CBot/tests/scenarios/fibo.txt → test/cbot/scenarios/fibo.txt
View File

0
src/CBot/tests/scenarios/file.txt → test/cbot/scenarios/file.txt
View File

0
src/CBot/tests/scenarios/h.txt → test/cbot/scenarios/h.txt
View File

0
src/CBot/tests/scenarios/include.txt → test/cbot/scenarios/include.txt
View File

0
src/CBot/tests/scenarios/intrinsic.txt → test/cbot/scenarios/intrinsic.txt
View File

0
src/CBot/tests/scenarios/methode1.txt → test/cbot/scenarios/methode1.txt
View File

0
src/CBot/tests/scenarios/methode2.txt → test/cbot/scenarios/methode2.txt
View File

0
src/CBot/tests/scenarios/mp1.txt → test/cbot/scenarios/mp1.txt
View File

0
src/CBot/tests/scenarios/mp2.txt → test/cbot/scenarios/mp2.txt
View File

0
src/CBot/tests/scenarios/mw.txt → test/cbot/scenarios/mw.txt
View File

0
src/CBot/tests/scenarios/null.txt → test/cbot/scenarios/null.txt
View File

0
src/CBot/tests/scenarios/opnew.txt → test/cbot/scenarios/opnew.txt
View File

0
src/CBot/tests/scenarios/plante.txt → test/cbot/scenarios/plante.txt
View File

0
src/CBot/tests/scenarios/pointer.txt → test/cbot/scenarios/pointer.txt
View File

0
src/CBot/tests/scenarios/postinc.txt → test/cbot/scenarios/postinc.txt
View File

0
src/CBot/tests/scenarios/radar.txt → test/cbot/scenarios/radar.txt
View File

0
src/CBot/tests/scenarios/solution.txt → test/cbot/scenarios/solution.txt
View File

0
src/CBot/tests/scenarios/test.txt → test/cbot/scenarios/test.txt
View File

0
src/CBot/tests/scenarios/test23.txt → test/cbot/scenarios/test23.txt
View File

0
src/CBot/tests/scenarios/testmw.txt → test/cbot/scenarios/testmw.txt
View File

0
src/CBot/tests/scenarios/this.txt → test/cbot/scenarios/this.txt
View File

0
src/CBot/tests/scenarios/tt.txt → test/cbot/scenarios/tt.txt
View File

0
src/CBot/tests/scenarios/tt2.txt → test/cbot/scenarios/tt2.txt
View File

0
src/CBot/tests/scenarios/vide.txt → test/cbot/scenarios/vide.txt
View File

0
src/CBot/tests/scenarios/zz.txt → test/cbot/scenarios/zz.txt
View File

2
test/envs/CMakeLists.txt Normal file
View File

@ -0,0 +1,2 @@
# OpenGL tests
add_subdirectory(opengl)

Some files were not shown because too many files have changed in this diff Show More