//========================================================================
void APlatformActor::Tick(float DeltaSeconds)
{
Super::Tick(DeltaSeconds);
if (m_Target)
{
auto z = FVector(0, 0, 30);
DrawDebugLine(GetWorld(), GetActorLocation() + z, m_Target->GetActorLocation() + z, FColor::Yellow, false, -1.f, 0, 1.3f);
auto d = 40.0f;
auto mypos = GetActorLocation();
bool hasCompanion = std::any_of(Cont(gHexEditor->m_AllCompanions), [&](auto& c) { return FVector::Dist(mypos, c->GetActorLocation()) < d; });
if (hasCompanion)
{
m_Target->Off();
return;
}
auto dist = FVector::Dist(gHexGame->Dude->GetActorLocation(), GetActorLocation());
if (dist < d)
{
m_Target->Off();
}
}
}
int
loadcel()
{
unsigned int j,i,len,ptr;
ffile = fopen(imagename,"r");
if(ffile == NULL) {
printf("%s does not exist\n",imagename);
return (NULL);
} else {
up(buf,(word)2,(word)0x10);
ptr = buf[0]+buf[1]*256;
i = getc(ffile);
j = getc(ffile);
len = i+j*256;
buf[0] = i;
buf[1] = j;
for(i=2;i<(len-2);i++)
buf[i] = getc(ffile);
fclose(ffile);
printf("%d\n",len);
down(buf,(word)len,(word)ptr);
buf[0] = 1;
down(buf,(word)1,(word)0x12);
Cont();
}
}
std::vector<FieldContainerUnrecPtr> getAllContainersByDerivedType(const FieldContainerType *szType)
{
std::vector<FieldContainerUnrecPtr> Result;
const FieldContainerFactoryBase::ContainerStore &FCStore( FieldContainerFactory::the()->getFieldContainerStore () );
FieldContainerFactoryBase::ContainerStore::const_iterator FCStoreIter;
FieldContainerFactoryBase::ContainerPtr Cont(NULL);
for(FCStoreIter = FCStore.begin() ; FCStoreIter != FCStore.end() ; ++FCStoreIter)
{
if(*FCStoreIter != NULL)
{
#ifdef OSG_MT_CPTR_ASPECT
Cont = (*FCStoreIter)->getPtr();
#else
Cont = *FCStoreIter;
#endif
}
else
{
Cont = NULL;
}
if( Cont != NULL && Cont->getType().isDerivedFrom(*szType) )
{
Result.push_back(Cont);
}
}
return Result;
}
int
put_a_sequence()
{
unsigned int put_sequence,ptr,j,k;
display_existing_sequences();
printf("\nSequence # to put >");
fflush(stdin);
gets(tempstr1);
sscanf(tempstr1,"%d",&put_sequence);
if (sequence_flag[put_sequence]==0) {
printf("\nThat sequence does not exist\n");
return;
}
up(buf,(word)2,(word)0x13);
ptr = buf[0]+buf[1]*256;
for(j=0;j<8;j++)
for(k=0;k<sequence_length;k++)
buf[j*sequence_length+k] = sequence_data[put_sequence][j][k];
for(j=0;j<8;j++)
buf[8*sequence_length+j] = visible_flag[put_sequence][j];
buf[8*sequence_length+8] = 1; /* sequencer on */
buf[8*sequence_length+9] = 255; /* working cel = none */
down(buf,(word)8*sequence_length+8+1+1,(word)ptr);
Cont();
}
int
get_a_sequence()
{
unsigned int get_sequence,ptr,j,k;
display_existing_sequences();
printf("\nSequence # to get >");
fflush(stdin);
gets(tempstr1);
sscanf(tempstr1,"%d",&get_sequence);
if (get_sequence<0 || get_sequence > max_sequences) {
printf("\nYou have selected an illegal sequence number\n");
return;
}
up(buf,(word)2,(word)0x13);
ptr = buf[0]+buf[1]*256;
up(buf,(word)8*sequence_length+8,(word)ptr);
Cont();
for(j=0;j<8;j++)
for(k=0;k<sequence_length;k++)
sequence_data[get_sequence][j][k] = buf[j*sequence_length+k];
for(j=0;j<8;j++)
visible_flag[get_sequence][j] = buf[8*sequence_length+j];
sequence_flag[get_sequence] = 1;
}
/// Return external program pointer for program sign.
/// @note Expect @p prg is in @c externalProgram.
static inline
pm_ext_program get_ext_program(sc_addr prg)
{
const Content *c = system_session->get_content_const(prg);
if (c->type() == TCINT) {
return reinterpret_cast<pm_ext_program>(Cont(*c).i);
} else {
return load_ext_program(prg);
}
}
Cont to_container() const
{
if (pred)
{
Cont ret;
std::copy_if(begin, end, std::inserter(ret, std::end(ret)), pred);
return ret;
}
return Cont(begin, end);
}
int
savecel()
{
unsigned int i,len,ptr;
ffile = fopen(imagename,"w");
if(ffile == NULL) {
printf("%s does not exist\n",imagename);
return (NULL);
} else {
printf("saving image \"%s\"\n",imagename);
up(buf,(word)2,(word)0x10);
ptr = buf[0]+buf[1]*256;
up(buf,(word)2,(word)ptr);
len = buf[0]+buf[1]*256;
printf("%d",len);
up(buf,(word)len,(word)ptr);
for(i=0;i<len;i++)
putc(buf[i],ffile);
fclose(ffile);
Cont();
}
}
void test(const Cont &)
{
// Testing if all types are provided.
typename Cont::value_type t0;
typename Cont::reference t1 = t0; CGAL_USE(t1);
typename Cont::const_reference t2 = t0; CGAL_USE(t2);
typename Cont::pointer t3 = &t0;
typename Cont::const_pointer t4 = &t0; CGAL_USE(t4);
typename Cont::size_type t5 = 0; CGAL_USE(t5);
typename Cont::difference_type t6 = t3-t3; CGAL_USE(t6);
typename Cont::iterator t7; CGAL_USE(t7);
typename Cont::const_iterator t8; CGAL_USE(t8);
typename Cont::reverse_iterator t9; CGAL_USE(t9);
typename Cont::const_reverse_iterator t10; CGAL_USE(t10);
typename Cont::allocator_type t15;
std::cout << "Testing empty containers." << std::endl;
Cont c0, c1;
Cont c2(t15);
Cont c3(c2);
Cont c4;
c4 = c2;
typedef std::vector<typename Cont::value_type> Vect;
Vect v0;
const Cont c5(v0.begin(), v0.end());
Cont c6(c5.begin(), c5.end());
typename Cont::allocator_type Al;
Cont c7(c0.begin(), c0.end(), Al);
Cont c8;
c8.insert(c0.rbegin(), c0.rend());
// test conversion iterator-> const_iterator.
typename Cont::const_iterator t16 = c5.begin(); CGAL_USE(t16);
assert(t16 == c5.begin());
assert(c0 == c1);
assert(! (c0 < c1));
assert(check_empty(c0));
assert(check_empty(c1));
assert(check_empty(c2));
assert(check_empty(c3));
assert(check_empty(c4));
assert(check_empty(c5));
assert(check_empty(c6));
assert(check_empty(c7));
assert(check_empty(c8));
c1.swap(c0);
assert(check_empty(c0));
assert(check_empty(c1));
c1.merge(c0);
assert(check_empty(c0));
assert(check_empty(c1));
typename Cont::allocator_type t20 = c0.get_allocator();
std::cout << "Now filling some containers" << std::endl;
Vect v1(10000);
Cont c9(v1.begin(), v1.end());
assert(c9.size() == v1.size());
assert(c9.max_size() >= v1.size());
assert(c9.capacity() >= c9.size());
Cont c10 = c9;
assert(c10 == c9);
assert(c10.size() == v1.size());
assert(c10.max_size() >= v1.size());
assert(c10.capacity() >= c10.size());
c9.clear();
assert(check_empty(c9));
assert(c9.capacity() >= c9.size());
assert(c0 == c9);
c9.merge(c10);
c10.swap(c9);
assert(check_empty(c9));
assert(c9.capacity() >= c9.size());
assert(c10.size() == v1.size());
assert(c10.max_size() >= v1.size());
assert(c10.capacity() >= c10.size());
std::cout << "Testing insertion methods" << std::endl;
c9.assign(c10.begin(), c10.end());
assert(c9 == c10);
c10.assign(c9.begin(), c9.end());
assert(c9 == c10);
c9.insert(c10.begin(), c10.end());
assert(c9.size() == 2*v1.size());
c9.clear();
assert(c9 != c10);
c9.insert(c10.begin(), c10.end());
assert(c9.size() == v1.size());
assert(c9 == c10);
typename Cont::iterator it = c9.iterator_to(*c9.begin());
assert(it == c9.begin());
typename Cont::const_iterator cit = c9.iterator_to(const_cast<typename Cont::const_reference>(*c9.begin()));
assert(cit == c9.begin());
typename Cont::iterator s_it = Cont::s_iterator_to(*c9.begin());
assert(s_it == c9.begin());
typename Cont::const_iterator s_cit = Cont::s_iterator_to(const_cast<typename Cont::const_reference>(*c9.begin()));
assert(s_cit == c9.begin());
c10 = Cont();
assert(check_empty(c10));
for(typename Vect::const_iterator it = v1.begin(); it != v1.end(); ++it)
c10.insert(*it);
assert(c10.size() == v1.size());
assert(c9 == c10);
c9.erase(c9.begin());
c9.erase(c9.begin());
assert(c9.size() == v1.size() - 2);
// test reserve
/*Cont c11;
c11.reserve(v1.size());
for(typename Vect::const_iterator it = v1.begin(); it != v1.end(); ++it)
c11.insert(*it);
assert(c11.size() == v1.size());
assert(c10 == c11);*/
// owns() and owns_dereferencable().
for(typename Cont::const_iterator it = c9.begin(), end = c9.end(); it != end; ++it) {
assert(c9.owns(it));
assert(c9.owns_dereferencable(it));
assert(! c10.owns(it));
assert(! c10.owns_dereferencable(it));
}
assert(c9.owns(c9.end()));
assert(! c9.owns_dereferencable(c9.end()));
c9.erase(c9.begin(), c9.end());
assert(check_empty(c9));
std::cout << "Testing parallel insertion" << std::endl;
{
Cont c11;
Vect v11(1000000);
std::vector<typename Cont::iterator> iterators(v11.size());
tbb::parallel_for(
tbb::blocked_range<size_t>( 0, v11.size() ),
Insert_in_CCC_functor<Vect, Cont>(v11, c11, iterators)
);
assert(c11.size() == v11.size());
std::cout << "Testing parallel erasure" << std::endl;
tbb::parallel_for(
tbb::blocked_range<size_t>( 0, v11.size() ),
Erase_in_CCC_functor<Cont>(c11, iterators)
);
assert(c11.empty());
}
std::cout << "Testing parallel insertion AND erasure" << std::endl;
{
Cont c12;
Vect v12(1000000);
std::vector<tbb::atomic<bool> > free_elements(v12.size());
for(typename std::vector<tbb::atomic<bool> >::iterator
it = free_elements.begin(), end = free_elements.end(); it != end; ++it)
{
*it = true;
}
tbb::atomic<unsigned int> num_erasures;
num_erasures = 0;
std::vector<typename Cont::iterator> iterators(v12.size());
tbb::parallel_for(
tbb::blocked_range<size_t>( 0, v12.size() ),
Insert_and_erase_in_CCC_functor<Vect, Cont>(
v12, c12, iterators, free_elements, num_erasures)
);
assert(c12.size() == v12.size() - num_erasures);
}
}
main() {
portstr = getenv("FASTPORT");
if(portstr!=NULL) {
if(strlen(portstr)<3) {
fprintf(stderr, "FASTPORT environment variable must be");
fprintf(stderr, " form: c;p. c and p are numerals for card");
fprintf(stderr, " and port respectively\n");
return -1;
} else {
card = portstr[0] - '0';
port = portstr[2] - '0';
}
}
if(card<0 || card>=NCARDS) {
fprintf(stderr, "card number out of range\n");
return -1;
}
if(port<0 || port>2) {
fprintf(stderr, "port number out of range\n");
return -1;
}
if(!Init(card, port)) {
fprintf(stderr, "Unable to access device\n");
Finish();
exit(-1);
}
getflag = 0;
oldxoffset = 0;
oldyoffset = 0;
strcpy(imagename,"image.cel");
xmax = 40;
ymax = 25;
while(1) {
printmenu();
gets(tempstr);
c = tempstr[0];
printf("\n");
if(c == 'i') {
system("down -S < /u1/gg/bin/face64.out");
newcel();
}
if(c == 'd') {
system("ls -C *.cel | more");
}
if(c == '!') {
printf("Unix command >");
fflush(stdin) ;
gets(tempstr);
printf("\n");
system(tempstr);
printf("\nhit return to continue");
fflush(stdin);
gets(tempstr);
}
if(c == 'h') {
if(fopen("/u1/gg/bin/face.doc","r") == NULL) {
printf("\nHelp file not in /u1/gg/bin\n");
} else {
system("more /u1/gg/bin/face.doc");
}
}
if(c == 'l') {
getimagename();
loadcel();
}
if(c == 's') {
getimagename();
savecel();
}
if(c == 'n') {
newcel();
}
if(c == 'r') {
getsequencename();
read_sequence_file();
getflag = 0;
}
if(c == 'w') {
getsequencename();
write_sequence_file();
getflag = 0;
}
if(c == 'g') {
get_a_sequence();
getflag = 1;
}
if(c == 'p') {
put_a_sequence();
}
if(c == 'P') {
buf[0] = 1;
down(buf,(word)1,(word)0x15);
Cont();
system("sleep 1");
ffile = fopen(".ptemp","w");
putc(40,ffile);
putc(14,ffile);
putc(0,ffile); /* black edges */
putc(0,ffile);
putc(0,ffile);
putc(0,ffile);
up(buf,(word)4480,(word)0xa000); /* get bitmap */
for(i=0;i<4480;i++) putc(buf[i],ffile);
for(i=0;i<560;i++) putc(0xde,ffile); /* pink/blue */
for(i=0;i<560;i++) putc(0x01,ffile); /* gray bkgrnd */
fclose(ffile);
system("pixit < .ptemp | lpr &");
buf[0] = 0;
down(buf,(word)1,(word)0x15);
Cont();
}
if(c == 'q') {
if (getflag) {
printf("sequences not written. Quit? (y/n)");
gets(tempstr);
c = tempstr[0];
printf("\n");
if (c == 'y') {
exit(0);
}
} else {
exit(0);
}
}
}
}