void TmpDisplayItem::init(const OdeHandle& odeHandle, const OsgHandle& osgHandle){
   Color mcolor(color);
   if(useColorName){
     mcolor = osgHandle.getColor(colorname);
     mcolor.alpha() = alpha;
   }
   item->init(osgHandle.changeColor(mcolor), quality);
   item->setMatrix(pose);
   initialized=true;
 }
 void TmpPrimitive::init(const OdeHandle& odeHandle, const OsgHandle& osgHandle){
   Color mcolor(color);
   if(useColorName){
     mcolor = osgHandle.getColor(colorname);
     mcolor.alpha() = alpha;
   }
   item->init(odeHandle, mass, osgHandle.changeColor(mcolor), mode);
   item->setPose(pose);
   initialized=true;
 }
 void TmpJoint::init(const OdeHandle& odeHandle, const OsgHandle& osgHandle){
   Color mcolor(color);
   if(useColorName){
     mcolor = osgHandle.getColor(colorname);
     mcolor.alpha() = alpha;
   }
   joint->init(odeHandle, osgHandle.changeColor(mcolor),
               withVisual, visualSize, ignoreColl);
   initialized=true;
 }
mcolor(int k,int g[20][20])
{
    do
    {
        nextcolor(k,g);
        if(x[k]==0)
            return;
        if(k==n)
            display();
        else
            mcolor(k+1,g);
    }while(1);
}
int main()
{
    printf("Enter the no.of vertices:");
    scanf("%d",&n);
    printf("Enter the no.of colors:");
    scanf("%d",&m);
    int i,j;
    printf("Enter the matrix\n");
    for(i=1;i<=n;i++)
    for(j=1;j<=n;j++)
    scanf("%d",&g[i][j]);

    mcolor(1,g);
    return 0;
}
Beispiel #6
0
        virtual void select(int entnum, uimenu *menu) override
        {
            if ( ! started ) {
                started = true;
                padding = std::string(menu->pad_right - 1, ' ');
                for( auto &traits_iter : mutation_branch::get_all() ) {
                    vTraits.push_back( traits_iter.first );
                    pTraits[traits_iter.first] = ( p->has_trait( traits_iter.first ) );
                }
            }
            auto &mdata = mutation_branch::get( vTraits[entnum] );

            int startx = menu->w_width - menu->pad_right;
            for ( int i = 2; i < lastlen; i++ ) {
                mvwprintw(menu->window, i, startx, "%s", padding.c_str() );
            }

            mvwprintw(menu->window, 3, startx,
                      mdata.valid ? _("Valid") : _("Nonvalid"));
            int line2 = 4;

            if ( !mdata.prereqs.empty() ) {
                line2++;
                mvwprintz(menu->window, line2, startx, c_ltgray, _("Prereqs:"));
                for (auto &j : mdata.prereqs) {
                    mvwprintz(menu->window, line2, startx + 11, mcolor(j), "%s", mutation_branch::get_name( j ).c_str());
                    line2++;
                }
            }

            if ( !mdata.prereqs2.empty() ) {
                line2++;
                mvwprintz(menu->window, line2, startx, c_ltgray, _("Prereqs, 2d:"));
                for (auto &j : mdata.prereqs2) {
                    mvwprintz(menu->window, line2, startx + 15, mcolor(j), "%s", mutation_branch::get_name( j ).c_str());
                    line2++;
                }
            }

            if ( !mdata.threshreq.empty() ) {
                line2++;
                mvwprintz(menu->window, line2, startx, c_ltgray, _("Thresholds required:"));
                for (auto &j : mdata.threshreq) {
                    mvwprintz(menu->window, line2, startx + 21, mcolor(j), "%s", mutation_branch::get_name( j ).c_str());
                    line2++;
                }
            }

            if ( !mdata.cancels.empty() ) {
                line2++;
                mvwprintz(menu->window, line2, startx, c_ltgray, _("Cancels:"));
                for (auto &j : mdata.cancels) {
                    mvwprintz(menu->window, line2, startx + 11, mcolor(j), "%s", mutation_branch::get_name( j ).c_str());
                    line2++;
                }
            }

            if ( !mdata.replacements.empty() ) {
                line2++;
                mvwprintz(menu->window, line2, startx, c_ltgray, _("Becomes:"));
                for (auto &j : mdata.replacements) {
                    mvwprintz(menu->window, line2, startx + 11, mcolor(j), "%s", mutation_branch::get_name( j ).c_str());
                    line2++;
                }
            }

            if ( !mdata.additions.empty() ) {
                line2++;
                mvwprintz(menu->window, line2, startx, c_ltgray, _("Add-ons:"));
                for (auto &j : mdata.additions) {
                    mvwprintz(menu->window, line2, startx + 11, mcolor(j), "%s", mutation_branch::get_name( j ).c_str());
                    line2++;
                }
            }

            if ( !mdata.category.empty() ) {
                line2++;
                mvwprintz(menu->window, line2, startx, c_ltgray,  _("Category:"));
                for (auto &j : mdata.category) {
                    mvwprintw(menu->window, line2, startx + 11, "%s", j.c_str());
                    line2++;
                }
            }
            line2 += 2;

            mvwprintz(menu->window, line2, startx, c_ltgray, "pts: %d vis: %d ugly: %d",
                      mdata.points,
                      mdata.visibility,
                      mdata.ugliness
                     );
            line2 += 2;

            std::vector<std::string> desc = foldstring( mdata.description,
                                            menu->pad_right - 1 );
            for( auto &elem : desc ) {
                mvwprintz( menu->window, line2, startx, c_ltgray, "%s", elem.c_str() );
                line2++;
            }
            lastlen = line2 + 1;

            mvwprintz(menu->window, menu->w_height - 3, startx, c_green, "%s", msg.c_str());
            msg = padding;
            mvwprintw(menu->window, menu->w_height - 2, startx, _("[/] find, [q]uit"));

        };
Beispiel #7
0
        virtual void select(int entnum, uimenu *menu) {
            if ( ! started ) {
                started = true;
                padding = std::string(menu->pad_right - 1, ' ');
                for (std::map<std::string, trait>::iterator iter = traits.begin(); iter != traits.end(); ++iter) {
                    vTraits.push_back(iter->first);
                    pTraits[iter->first] = ( p->has_trait( iter->first ) );
                }
            }

            int startx = menu->w_width - menu->pad_right;
            for ( int i = 1; i < lastlen; i++ ) {
                mvwprintw(menu->window, i, startx, "%s", padding.c_str() );
            }

            mvwprintw(menu->window, 1, startx,
                      mutation_data[vTraits[ entnum ]].valid ? _("Valid") : _("Nonvalid"));
            int line2 = 2;

            if ( !mutation_data[vTraits[entnum]].prereqs.empty() ) {
                line2++;
                mvwprintz(menu->window, line2, startx, c_ltgray, _("Prereqs:"));
                for (int j = 0; j < mutation_data[vTraits[ entnum ]].prereqs.size(); j++) {
                    std::string mstr = mutation_data[vTraits[ entnum ]].prereqs[j];
                    mvwprintz(menu->window, line2, startx + 11, mcolor(mstr), "%s", traits[ mstr ].name.c_str());
                    line2++;
                }
            }

            if ( !mutation_data[vTraits[entnum]].prereqs2.empty() ) {
                line2++;
                mvwprintz(menu->window, line2, startx, c_ltgray, _("Prereqs, 2d:"));
                for (int j = 0; j < mutation_data[vTraits[ entnum ]].prereqs2.size(); j++) {
                    std::string mstr = mutation_data[vTraits[ entnum ]].prereqs2[j];
                    mvwprintz(menu->window, line2, startx + 15, mcolor(mstr), "%s", traits[ mstr ].name.c_str());
                    line2++;
                }
            }

            if ( !mutation_data[vTraits[entnum]].threshreq.empty() ) {
                line2++;
                mvwprintz(menu->window, line2, startx, c_ltgray, _("Thresholds required:"));
                for (int j = 0; j < mutation_data[vTraits[ entnum ]].threshreq.size(); j++) {
                    std::string mstr = mutation_data[vTraits[ entnum ]].threshreq[j];
                    mvwprintz(menu->window, line2, startx + 21, mcolor(mstr), "%s", traits[ mstr ].name.c_str());
                    line2++;
                }
            }

            if ( !mutation_data[vTraits[entnum]].cancels.empty() ) {
                line2++;
                mvwprintz(menu->window, line2, startx, c_ltgray, _("Cancels:"));
                for (int j = 0; j < mutation_data[vTraits[ entnum ]].cancels.size(); j++) {
                    std::string mstr = mutation_data[vTraits[ entnum ]].cancels[j];
                    mvwprintz(menu->window, line2, startx + 11, mcolor(mstr), "%s", traits[ mstr ].name.c_str());
                    line2++;
                }
            }

            if ( !mutation_data[vTraits[entnum]].replacements.empty() ) {
                line2++;
                mvwprintz(menu->window, line2, startx, c_ltgray, _("Becomes:"));
                for (int j = 0; j < mutation_data[vTraits[ entnum ]].replacements.size(); j++) {
                    std::string mstr = mutation_data[vTraits[ entnum ]].replacements[j];
                    mvwprintz(menu->window, line2, startx + 11, mcolor(mstr), "%s", traits[ mstr ].name.c_str());
                    line2++;
                }
            }

            if ( !mutation_data[vTraits[entnum]].additions.empty() ) {
                line2++;
                mvwprintz(menu->window, line2, startx, c_ltgray, _("Add-ons:"));
                for (int j = 0; j < mutation_data[vTraits[ entnum ]].additions.size(); j++) {
                    std::string mstr = mutation_data[vTraits[ entnum ]].additions[j];
                    mvwprintz(menu->window, line2, startx + 11, mcolor(mstr), "%s", traits[ mstr ].name.c_str());
                    line2++;
                }
            }

            if ( !mutation_data[vTraits[entnum]].category.empty() ) {
                line2++;
                mvwprintz(menu->window, line2, startx, c_ltgray,  _("Category:"));
                for (int j = 0; j < mutation_data[vTraits[ entnum ]].category.size(); j++) {
                    mvwprintw(menu->window, line2, startx + 11, "%s", mutation_data[vTraits[ entnum ]].category[j].c_str());
                    line2++;
                }
            }
            line2 += 2;

            mvwprintz(menu->window, line2, startx, c_ltgray, "pts: %d vis: %d ugly: %d",
                      traits[vTraits[entnum]].points,
                      traits[vTraits[entnum]].visibility,
                      traits[vTraits[entnum]].ugliness
                     );
            line2 += 2;

            std::vector<std::string> desc = foldstring( traits[vTraits[ entnum ]].description,
                                            menu->pad_right - 1 );
            for( size_t j = 0; j < desc.size(); ++j ) {
                mvwprintz(menu->window, line2, startx, c_ltgray, "%s", desc[j].c_str() );
                line2++;
            }
            lastlen = line2 + 1;

            mvwprintz(menu->window, menu->w_height - 3, startx, c_green, "%s", msg.c_str());
            msg = padding;
            mvwprintw(menu->window, menu->w_height - 2, startx, _("[/] find, [q]uit"));

        };
Beispiel #8
0
        void select( int entnum, uimenu *menu ) override {
            if( ! started ) {
                started = true;
                padding = std::string( menu->pad_right - 1, ' ' );
                for( auto &traits_iter : mutation_branch::get_all() ) {
                    vTraits.push_back( traits_iter.first );
                    pTraits[traits_iter.first] = ( p->has_trait( traits_iter.first ) );
                }
            }
            const mutation_branch &mdata = vTraits[entnum].obj();

            int startx = menu->w_width - menu->pad_right;
            for( int i = 2; i < lastlen; i++ ) {
                mvwprintw( menu->window, i, startx, padding );
            }

            mvwprintw( menu->window, 3, startx,
                       mdata.valid ? _( "Valid" ) : _( "Nonvalid" ) );
            int line2 = 4;

            if( !mdata.prereqs.empty() ) {
                line2++;
                mvwprintz( menu->window, line2, startx, c_light_gray, _( "Prereqs:" ) );
                for( auto &j : mdata.prereqs ) {
                    mvwprintz( menu->window, line2, startx + 11, mcolor( j ),
                               mutation_branch::get_name( j ) );
                    line2++;
                }
            }

            if( !mdata.prereqs2.empty() ) {
                line2++;
                mvwprintz( menu->window, line2, startx, c_light_gray, _( "Prereqs, 2d:" ) );
                for( auto &j : mdata.prereqs2 ) {
                    mvwprintz( menu->window, line2, startx + 15, mcolor( j ),
                               mutation_branch::get_name( j ) );
                    line2++;
                }
            }

            if( !mdata.threshreq.empty() ) {
                line2++;
                mvwprintz( menu->window, line2, startx, c_light_gray, _( "Thresholds required:" ) );
                for( auto &j : mdata.threshreq ) {
                    mvwprintz( menu->window, line2, startx + 21, mcolor( j ),
                               mutation_branch::get_name( j ) );
                    line2++;
                }
            }

            if( !mdata.cancels.empty() ) {
                line2++;
                mvwprintz( menu->window, line2, startx, c_light_gray, _( "Cancels:" ) );
                for( auto &j : mdata.cancels ) {
                    mvwprintz( menu->window, line2, startx + 11, mcolor( j ),
                               mutation_branch::get_name( j ) );
                    line2++;
                }
            }

            if( !mdata.replacements.empty() ) {
                line2++;
                mvwprintz( menu->window, line2, startx, c_light_gray, _( "Becomes:" ) );
                for( auto &j : mdata.replacements ) {
                    mvwprintz( menu->window, line2, startx + 11, mcolor( j ),
                               mutation_branch::get_name( j ) );
                    line2++;
                }
            }

            if( !mdata.additions.empty() ) {
                line2++;
                mvwprintz( menu->window, line2, startx, c_light_gray, _( "Add-ons:" ) );
                for( auto &j : mdata.additions ) {
                    mvwprintz( menu->window, line2, startx + 11, mcolor( j ),
                               mutation_branch::get_name( j ) );
                    line2++;
                }
            }

            if( !mdata.types.empty() ) {
                line2++;
                mvwprintz( menu->window, line2, startx, c_light_gray,  _( "Type:" ) );
                for( auto &j : mdata.types ) {
                    mvwprintw( menu->window, line2, startx + 11, j );
                    line2++;
                }
            }

            if( !mdata.category.empty() ) {
                line2++;
                mvwprintz( menu->window, line2, startx, c_light_gray,  _( "Category:" ) );
                for( auto &j : mdata.category ) {
                    mvwprintw( menu->window, line2, startx + 11, j );
                    line2++;
                }
            }
            line2 += 2;

            mvwprintz( menu->window, line2, startx, c_light_gray, "pts: %d vis: %d ugly: %d",
                       mdata.points,
                       mdata.visibility,
                       mdata.ugliness
                     );
            line2 += 2;

            std::vector<std::string> desc = foldstring( mdata.description,
                                            menu->pad_right - 1 );
            for( auto &elem : desc ) {
                mvwprintz( menu->window, line2, startx, c_light_gray, elem );
                line2++;
            }
            lastlen = line2 + 1;

            mvwprintz( menu->window, menu->w_height - 3, startx, c_green, msg );
            msg = padding;
            input_context ctxt( "UIMENU" );
            mvwprintw( menu->window, menu->w_height - 2, startx,
                       _( "[%s] find, [%s] quit, [t] toggle base trait" ),
                       ctxt.get_desc( "FILTER" ).c_str(), ctxt.get_desc( "QUIT" ).c_str() );

        };